Method sendStream

src/rpc.ts:786–822

(id: ImportId, path: PropertyPath, args: RpcPayload)

  }

  sendStream(id: ImportId, path: PropertyPath, args: RpcPayload)
      : {promise: Promise<void>, size: number} {
    if (this.abortReason) throw this.abortReason;

    let value: Array<any> = ["pipeline", id, path];
    let devalue = Devaluator.devaluate(args.value, undefined, this, args, this.encodingLevel);

    // HACK: Since the args is an array, devaluator will wrap in a second array. Need to unwrap.
    // TODO: Clean this up somehow.
    value.push((<Array<unknown>>devalue)[0]);

    let msg = ["stream", value];
    let size = this.send(msg);
    if (size === undefined) {
      size = estimateEncodedSize(msg);
    }

    // Create the import entry in "already pulling" state (pulling=true), since stream messages
    // are automatically pulled. Set remoteRefcount to 0 so that resolve() won't send a release
    // message — the server implicitly releases the export after sending the resolve. Set
    // localRefcount to 1 so that resolve() doesn't treat this as already-disposed.
    let importId = this.imports.length;
    let entry = new ImportTableEntry(this, importId, /*pulling=*/true);
    entry.remoteRefcount = 0;
    entry.localRefcount = 1;
    this.imports.push(entry);

    // Await the resolution, then dispose the result payload and clean up the import table entry.
    // (Normally, sendRelease() cleans up the import table, but since remoteRefcount is 0, we
    // need to do it manually.)
    let promise = entry.awaitResolution().then(
      p => { p.dispose(); delete this.imports[importId]; },
      err => { delete this.imports[importId]; throw err; }
    );

    return { promise, size };
  }

  sendMap(id: ImportId, path: PropertyPath, captures: StubHook[], instructions: unknown[])
      : RpcImportHook {