@nylorun/harness 0.12.0-beta → 0.15.0-beta

package/dist/build/builder.d.ts

@@ -1,38 +0,0 @@
-import type { BoundMiddleware, CapabilityDeclaration, StepMiddleware } from "../types/middleware.js";
-import type { BuildDiagnostic } from "../types/shared.js";
-import { HarnessError } from "../errors.js";
-import type { BuiltAgent } from "./agent.js";
-export interface AgentOptions {
-    readonly id: string;
-    readonly name: string;
-    readonly instructions?: string | readonly string[];
-}
-interface BuilderState {
-    readonly id: string;
-    readonly name: string;
-    readonly middleware: BoundMiddleware[];
-    sealed: boolean;
-    agent?: BuiltAgent;
-    error?: AgentBuildError;
-    middlewareSeq: number;
-}
-export declare class AgentBuildError extends HarnessError {
-    readonly diagnostics: readonly BuildDiagnostic[];
-    constructor(diagnostics: readonly BuildDiagnostic[]);
-}
-export declare class AgentLifecycleError extends HarnessError {
-    constructor(message: string);
-}
-export declare function Agent(options: AgentOptions): AgentBuilder;
-export declare class AgentBuilder {
-    private readonly state;
-    constructor(state: BuilderState);
-    use(middleware: StepMiddleware): this;
-    use(id: string, middleware: StepMiddleware): this;
-    use<State>(declaration: CapabilityDeclaration<State>): this;
-    build(): BuiltAgent;
-    private nextMiddlewareId;
-    private push;
-    private assertOpen;
-}
-export {};

package/dist/build/builder.js

@@ -1,136 +0,0 @@
-import { HarnessError } from "../errors.js";
-import { assembleAgent } from "./assemble.js";
-export class AgentBuildError extends HarnessError {
-    diagnostics;
-    constructor(diagnostics) {
-        super("agent.build-failed", diagnostics.map((item) => item.message).join("; ") || "Agent build failed");
-        this.diagnostics = diagnostics;
-        this.name = "AgentBuildError";
-    }
-}
-export class AgentLifecycleError extends HarnessError {
-    constructor(message) {
-        super("agent.lifecycle-sealed", message);
-        this.name = "AgentLifecycleError";
-    }
-}
-export function Agent(options) {
-    return new AgentBuilder(createState(options));
-}
-export class AgentBuilder {
-    state;
-    constructor(state) {
-        this.state = state;
-    }
-    use(idOrMiddleware, middleware) {
-        if (typeof idOrMiddleware === "function") {
-            return this.push({ id: this.nextMiddlewareId(), handle: idOrMiddleware });
-        }
-        if (typeof idOrMiddleware === "object")
-            return this.push(compileDeclaration(idOrMiddleware));
-        return this.push({ id: idOrMiddleware, handle: middleware });
-    }
-    build() {
-        if (this.state.agent)
-            return this.state.agent;
-        if (this.state.error)
-            throw this.state.error;
-        this.state.sealed = true;
-        const result = assembleAgent(this.state.middleware, {
-            id: this.state.id,
-            name: this.state.name,
-        });
-        if (!result.ok) {
-            this.state.error = new AgentBuildError(result.diagnostics);
-            throw this.state.error;
-        }
-        this.state.agent = result.agent;
-        return this.state.agent;
-    }
-    nextMiddlewareId() {
-        const taken = new Set(this.state.middleware.map((item) => item.id));
-        let id;
-        do {
-            this.state.middlewareSeq += 1;
-            id = `middleware-${this.state.middlewareSeq}`;
-        } while (taken.has(id));
-        return id;
-    }
-    push(entry) {
-        this.assertOpen();
-        this.state.middleware.push(entry);
-        return this;
-    }
-    assertOpen() {
-        if (this.state.sealed)
-            throw new AgentLifecycleError("AgentBuilder cannot be changed after build()");
-    }
-}
-function createState(options) {
-    const middleware = [];
-    if (options.instructions !== undefined) {
-        const instructions = typeof options.instructions === "string" ? [options.instructions] : options.instructions;
-        middleware.push(compileDeclaration({ id: "agent", instructions }));
-    }
-    return {
-        id: options.id,
-        name: options.name,
-        middleware,
-        sealed: false,
-        middlewareSeq: 0,
-    };
-}
-function compileDeclaration(declaration) {
-    const tools = copyItems(declaration.tools, declaration.id);
-    const instructions = copyItems(declaration.instructions, declaration.id);
-    const model = declaration.model;
-    const contributions = snapshotContributions(instructions?.items, tools?.items, model);
-    const handle = async (request, next) => {
-        if (tools)
-            request.configuration.tools.set(tools.slot, tools.items);
-        if (instructions)
-            request.configuration.instructions.set(instructions.slot, instructions.items);
-        if (model)
-            request.configuration.model.select(model);
-        return declaration.middleware ? declaration.middleware(request, next) : next();
-    };
-    return {
-        id: declaration.id,
-        handle,
-        ...(declaration.state === undefined
-            ? {}
-            : { state: declaration.state }),
-        ...(contributions === undefined ? {} : { contributions }),
-    };
-}
-function snapshotContributions(instructions, tools, model) {
-    const snapInstructions = instructions === undefined ? undefined : Object.freeze([...instructions]);
-    const snapTools = tools === undefined
-        ? undefined
-        : Object.freeze(tools.map((tool) => Object.freeze({
-            name: tool.name,
-            ...(tool.description === undefined ? {} : { description: tool.description }),
-        })));
-    const snapModel = model === undefined ? undefined : snapshotModel(model);
-    if (snapInstructions === undefined && snapTools === undefined && snapModel === undefined) {
-        return undefined;
-    }
-    return Object.freeze({
-        ...(snapInstructions === undefined ? {} : { instructions: snapInstructions }),
-        ...(snapTools === undefined ? {} : { tools: snapTools }),
-        ...(snapModel === undefined ? {} : { model: snapModel }),
-    });
-}
-function snapshotModel(model) {
-    return Object.freeze({
-        ...(model.id === undefined ? {} : { id: model.id }),
-        ...(model.controls === undefined ? {} : { controls: Object.freeze({ ...model.controls }) }),
-    });
-}
-function copyItems(value, defaultSlot) {
-    if (value === undefined)
-        return undefined;
-    if (!("items" in value))
-        return Object.freeze({ slot: defaultSlot, items: Object.freeze([...value]) });
-    return Object.freeze({ slot: value.slot, items: Object.freeze([...value.items]) });
-}

package/dist/build/helpers.d.ts

@@ -1,6 +0,0 @@
-import type { ModelAdapter } from "../types/model.js";
-import type { StepMiddleware } from "../types/middleware.js";
-import type { ToolDefinition, ToolInputSchema, ToolOutputSchema } from "../types/tool.js";
-export declare const tool: <InputSchema extends ToolInputSchema, State = never, OutputSchema extends ToolOutputSchema | undefined = undefined>(value: ToolDefinition<InputSchema, State, OutputSchema>) => ToolDefinition<InputSchema, State, OutputSchema>;
-export declare const model: <T extends ModelAdapter>(value: T) => T;
-export declare const middleware: <T extends StepMiddleware>(value: T) => T;

package/dist/build/helpers.js

@@ -1,4 +0,0 @@
-import { prepareTool } from "./schema.js";
-export const tool = (value) => prepareTool(value);
-export const model = (value) => value;
-export const middleware = (value) => value;

package/dist/build/manifest.d.ts

@@ -1,7 +0,0 @@
-import type { AgentManifest } from "../types/manifest.js";
-import type { BoundMiddleware } from "../types/middleware.js";
-export declare function createManifest(input: {
-    id: string;
-    name: string;
-    middleware: readonly BoundMiddleware[];
-}): AgentManifest;

package/dist/build/manifest.js

@@ -1,20 +0,0 @@
-import { deepFreeze } from "../utils/immutable.js";
-export function createManifest(input) {
-    const middleware = input.middleware.map((item) => projectMiddleware(item));
-    return deepFreeze({
-        id: input.id,
-        name: input.name,
-        middleware,
-    });
-}
-function projectMiddleware(item) {
-    const contributions = item.contributions;
-    return {
-        id: item.id,
-        ...(contributions?.instructions === undefined
-            ? {}
-            : { instructions: contributions.instructions }),
-        ...(contributions?.tools === undefined ? {} : { tools: contributions.tools }),
-        ...(contributions?.model === undefined ? {} : { model: contributions.model }),
-    };
-}

package/dist/build/schema.d.ts

@@ -1,14 +0,0 @@
-import type { BoundToolSchema, ToolDefinition, ToolSchema, ToolSchemaSource } from "../types/tool.js";
-export type { SchemaValidation } from "../types/tool.js";
-interface NormalizedToolSchemas {
-    readonly inputSchema: BoundToolSchema<unknown>;
-    readonly outputSchema?: BoundToolSchema<unknown>;
-}
-/** Creates a portable, explicitly validated schema source from raw JSON Schema. */
-export declare function defineSchema<T>(value: ToolSchema<T>): ToolSchema<T>;
-/** Eagerly prepares a definition authored through Harness's tool() helper. */
-export declare function prepareTool<T extends ToolDefinition>(definition: T): T;
-/** Returns cached normalized contracts, preparing raw definitions on first bind. */
-export declare function normalizedSchemasFor(definition: ToolDefinition): NormalizedToolSchemas;
-/** Converts an accepted tool schema source into Harness's immutable runtime representation. */
-export declare function normalizeSchema<T>(source: ToolSchemaSource<T>, role: "input" | "output"): BoundToolSchema<T>;

package/dist/build/schema.js

@@ -1,205 +0,0 @@
-import { z } from "zod";
-import { HarnessError } from "../errors.js";
-import { copyJsonObject } from "../utils/immutable.js";
-const preparedSchemas = new WeakMap();
-/** Creates a portable, explicitly validated schema source from raw JSON Schema. */
-export function defineSchema(value) {
-    if (!value || typeof value !== "object" || typeof value.validate !== "function")
-        throw new HarnessError("tool.invalid-schema", "Tool schema must provide validate()");
-    return Object.freeze({
-        jsonSchema: copyJsonObject(value.jsonSchema, "tool schema jsonSchema"),
-        validate: value.validate.bind(value),
-    });
-}
-/** Eagerly prepares a definition authored through Harness's tool() helper. */
-export function prepareTool(definition) {
-    normalizedSchemasFor(definition);
-    return definition;
-}
-/** Returns cached normalized contracts, preparing raw definitions on first bind. */
-export function normalizedSchemasFor(definition) {
-    const cached = preparedSchemas.get(definition);
-    if (cached)
-        return cached;
-    const normalized = Object.freeze({
-        inputSchema: normalizeSchema(definition.inputSchema, "input"),
-        ...(definition.outputSchema === undefined
-            ? {}
-            : { outputSchema: normalizeSchema(definition.outputSchema, "output") }),
-    });
-    preparedSchemas.set(definition, normalized);
-    return normalized;
-}
-/** Converts an accepted tool schema source into Harness's immutable runtime representation. */
-export function normalizeSchema(source, role) {
-    const normalized = isZodSchema(source)
-        ? normalizeZodSchema(source, role)
-        : isStandardSchema(source)
-            ? normalizeStandardSchema(source, role)
-            : isToolSchema(source)
-                ? normalizeExplicitSchema(source)
-                : undefined;
-    if (!normalized)
-        throw new HarnessError("tool.invalid-schema", "Tool schema must be a Zod schema, synchronous Standard Schema with JSON Schema conversion, or defineSchema() contract");
-    if (role === "input" && normalized.jsonSchema.type !== "object")
-        throw new HarnessError("tool.invalid-schema", "Tool inputSchema JSON Schema root type must be object");
-    return normalized;
-}
-function normalizeZodSchema(source, role) {
-    if (hasDeclaredAsyncWork(source))
-        throw new HarnessError("tool.invalid-schema", "Tool schema must validate synchronously");
-    let jsonSchema;
-    try {
-        jsonSchema = copyJsonObject(z.toJSONSchema(source, { target: "draft-07" }), `tool.${role}Schema.jsonSchema`);
-    }
-    catch (error) {
-        throw new HarnessError("tool.invalid-schema", `Tool ${role}Schema must convert to JSON Schema: ${message(error)}`, { cause: error });
-    }
-    return Object.freeze({
-        jsonSchema,
-        validate(value) {
-            try {
-                const result = source.safeParse(value);
-                if (result.success)
-                    return { ok: true, value: result.data };
-                return {
-                    ok: false,
-                    issues: Object.freeze(result.error.issues.map((entry) => issue(entry.path.filter(isPathSegment), entry.code, entry.message))),
-                };
-            }
-            catch (error) {
-                return { ok: false, issues: [issue([], "schema_error", synchronousIssue(error))] };
-            }
-        },
-    });
-}
-function normalizeStandardSchema(source, role) {
-    let jsonSchema;
-    try {
-        jsonSchema = copyJsonObject(role === "input"
-            ? source["~standard"].jsonSchema.input()
-            : source["~standard"].jsonSchema.output(), `tool.${role}Schema.jsonSchema`);
-    }
-    catch (error) {
-        throw new HarnessError("tool.invalid-schema", `Tool ${role}Schema must convert to JSON Schema: ${message(error)}`, { cause: error });
-    }
-    return Object.freeze({
-        jsonSchema,
-        validate(value) {
-            try {
-                const result = source["~standard"].validate(value);
-                if (isPromiseLike(result))
-                    return {
-                        ok: false,
-                        issues: [issue([], "async_validation", "Schema validation must be synchronous")],
-                    };
-                if (result && typeof result === "object" && "issues" in result && result.issues)
-                    return { ok: false, issues: Object.freeze(result.issues.map(standardIssue)) };
-                if (result && typeof result === "object" && "value" in result)
-                    return { ok: true, value: result.value };
-                return {
-                    ok: false,
-                    issues: [issue([], "schema_error", "Standard Schema returned an invalid result")],
-                };
-            }
-            catch (error) {
-                return { ok: false, issues: [issue([], "schema_error", synchronousIssue(error))] };
-            }
-        },
-    });
-}
-function normalizeExplicitSchema(source) {
-    return Object.freeze({
-        jsonSchema: copyJsonObject(source.jsonSchema, "tool schema jsonSchema"),
-        validate(value) {
-            try {
-                const result = source.validate(value);
-                if (isPromiseLike(result))
-                    return {
-                        ok: false,
-                        issues: [issue([], "async_validation", "Schema validation must be synchronous")],
-                    };
-                if (!result || typeof result !== "object" || typeof result.ok !== "boolean")
-                    return {
-                        ok: false,
-                        issues: [issue([], "schema_error", "Tool schema returned an invalid result")],
-                    };
-                if (result.ok)
-                    return { ok: true, value: result.value };
-                return { ok: false, issues: Object.freeze(result.issues.map(normalizeIssue)) };
-            }
-            catch (error) {
-                return { ok: false, issues: [issue([], "schema_error", synchronousIssue(error))] };
-            }
-        },
-    });
-}
-function isZodSchema(value) {
-    return value instanceof z.ZodType;
-}
-function isStandardSchema(value) {
-    if (!value || typeof value !== "object" || !("~standard" in value))
-        return false;
-    const standard = value["~standard"];
-    if (!standard || typeof standard !== "object")
-        return false;
-    const record = standard;
-    if (typeof record.validate !== "function" ||
-        !record.jsonSchema ||
-        typeof record.jsonSchema !== "object")
-        return false;
-    const jsonSchema = record.jsonSchema;
-    return typeof jsonSchema.input === "function" && typeof jsonSchema.output === "function";
-}
-function isToolSchema(value) {
-    return (!!value &&
-        typeof value === "object" &&
-        "jsonSchema" in value &&
-        "validate" in value &&
-        typeof value.validate === "function");
-}
-/** Zod exposes declared checks in its stable v4 definition graph; reject async checks before a run. */
-function hasDeclaredAsyncWork(schema) {
-    return visitDefinition(schema._zod?.def, new Set());
-}
-function visitDefinition(value, seen) {
-    if (typeof value === "function")
-        return value.constructor.name === "AsyncFunction";
-    if (!value || typeof value !== "object")
-        return false;
-    if (seen.has(value))
-        return false;
-    seen.add(value);
-    const nestedDefinition = value._zod?.def;
-    if (nestedDefinition !== undefined && nestedDefinition !== value)
-        return visitDefinition(nestedDefinition, seen);
-    for (const item of Object.values(value)) {
-        if (visitDefinition(item, seen))
-            return true;
-    }
-    return false;
-}
-function standardIssue(value) {
-    return issue(value.path?.filter(isPathSegment) ?? [], value.code ?? "invalid", value.message ?? "Invalid value");
-}
-function normalizeIssue(value) {
-    return issue(value.path?.filter(isPathSegment) ?? [], value.code ?? "invalid", value.message ?? "Invalid value");
-}
-function issue(path, code, text) {
-    return Object.freeze({ path: Object.freeze([...path]), code, message: text });
-}
-function isPathSegment(value) {
-    return typeof value === "string" || typeof value === "number";
-}
-function isPromiseLike(value) {
-    return (!!value && typeof value === "object" && typeof value.then === "function");
-}
-function synchronousIssue(error) {
-    const reason = message(error);
-    return reason.includes("Promise during synchronous parse")
-        ? "Schema validation must be synchronous"
-        : reason;
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/errors.d.ts

@@ -1,17 +0,0 @@
-/** Machine-readable error raised by Harness-owned code. */
-export type HarnessErrorCode = "agent.build-failed" | "agent.lifecycle-sealed" | "capability.state.create-failed" | "capability.state.undeclared" | "context.invalid-item" | "context.invalid-item-type" | "context.invalid-order" | "context.invalid-reason" | "context.invalid-slot" | "interaction.invalid" | "interaction.missing-resume" | "interaction.uncorrelated-resume" | "input.invalid-content" | "output.invalid" | "output.invalid-schema" | "json.invalid-data" | "json.invalid-object" | "middleware.next-after-return" | "middleware.next-called-twice" | "middleware.request-mutators-revoked" | "model.candidate-missing" | "model.adapter-invalid-options" | "model.adapter-invalid-response" | "model.invalid-candidate" | "model.invalid-directive" | "model.unsupported-content" | "model.unsupported-output-schema" | "configuration.duplicate-tool-name" | "configuration.invalid" | "configuration.invalid-instructions" | "configuration.invalid-order" | "configuration.invalid-reason" | "configuration.invalid-slot" | "configuration.invalid-tools" | "configuration.model-selection-conflict" | "response.invalid-replacement" | "session.invalid-seed" | "session.record-failed" | "session.stale-result" | "tool.invalid" | "tool.invalid-arguments" | "tool.invalid-output" | "tool.invalid-name" | "tool.invalid-schema" | "tool.invalid-tool-result";
-export type HarnessErrorDetails = Readonly<Record<string, string | number | boolean>>;
-export interface HarnessErrorOptions {
-    readonly cause?: unknown;
-    readonly details?: HarnessErrorDetails;
-}
-/**
- * The sole error shape produced by Harness itself. Message text is explanatory;
- * callers must branch on `code`.
- */
-export declare class HarnessError extends Error {
-    readonly code: HarnessErrorCode;
-    readonly details: HarnessErrorDetails;
-    constructor(code: HarnessErrorCode, message: string, options?: HarnessErrorOptions);
-}
-export declare function isHarnessError(error: unknown): error is HarnessError;

package/dist/errors.js

@@ -1,17 +0,0 @@
-/**
- * The sole error shape produced by Harness itself. Message text is explanatory;
- * callers must branch on `code`.
- */
-export class HarnessError extends Error {
-    code;
-    details;
-    constructor(code, message, options = {}) {
-        super(message, options.cause === undefined ? undefined : { cause: options.cause });
-        this.name = "HarnessError";
-        this.code = code;
-        this.details = Object.freeze({ ...(options.details ?? {}) });
-    }
-}
-export function isHarnessError(error) {
-    return error instanceof HarnessError;
-}

package/dist/session/capability-state.d.ts

@@ -1,14 +0,0 @@
-import type { BoundMiddleware } from "../types/middleware.js";
-import type { SessionIdentity } from "../types/session.js";
-import type { ObserveEmit } from "../utils/observe.js";
-/** Owns declared, process-local state for exactly one Session. */
-export declare class CapabilityStateRegistry {
-    #private;
-    private readonly session;
-    private readonly observe;
-    constructor(middleware: readonly BoundMiddleware[], session: SessionIdentity, observe: ObserveEmit);
-    has(id: string): boolean;
-    get(id: string): Promise<unknown>;
-    abort(reason: unknown): void;
-    shutdown(reason: unknown): Promise<void>;
-}

package/dist/session/capability-state.js

@@ -1,67 +0,0 @@
-import { HarnessError } from "../errors.js";
-/** Owns declared, process-local state for exactly one Session. */
-export class CapabilityStateRegistry {
-    session;
-    observe;
-    #entries = new Map();
-    #controller = new AbortController();
-    #shutdown;
-    constructor(middleware, session, observe) {
-        this.session = session;
-        this.observe = observe;
-        for (const middlewareEntry of middleware) {
-            if (middlewareEntry.state)
-                this.#entries.set(middlewareEntry.id, {
-                    id: middlewareEntry.id,
-                    state: middlewareEntry.state,
-                });
-        }
-    }
-    has(id) {
-        return this.#entries.has(id);
-    }
-    get(id) {
-        const entry = this.#entries.get(id);
-        if (!entry)
-            return Promise.reject(new HarnessError("capability.state.undeclared", `Capability '${id}' did not declare session state`));
-        if (!entry.promise) {
-            entry.promise = Promise.resolve()
-                .then(() => entry.state.create(this.session, this.#controller.signal))
-                .then((value) => {
-                entry.value = value;
-                entry.created = true;
-                return value;
-            }, (cause) => {
-                throw new HarnessError("capability.state.create-failed", `Capability '${id}' failed to create session state`, { cause });
-            });
-        }
-        return entry.promise;
-    }
-    abort(reason) {
-        this.#controller.abort(reason);
-    }
-    shutdown(reason) {
-        if (this.#shutdown)
-            return this.#shutdown;
-        this.abort(reason);
-        this.#shutdown = (async () => {
-            const created = [...this.#entries.values()].filter((entry) => entry.promise);
-            await Promise.allSettled(created.map((entry) => entry.promise));
-            for (const entry of [...created].reverse()) {
-                if (!entry.created || !entry.state.dispose)
-                    continue;
-                try {
-                    await entry.state.dispose(entry.value);
-                }
-                catch (error) {
-                    this.observe({
-                        type: "capability.state.dispose.failed",
-                        capabilityId: entry.id,
-                        attributes: { message: error instanceof Error ? error.message : String(error) },
-                    });
-                }
-            }
-        })();
-        return this.#shutdown;
-    }
-}

package/dist/session/event-log.d.ts

@@ -1,12 +0,0 @@
-import type { SessionEvent } from "../types/session.js";
-import type { JsonValue } from "../types/shared.js";
-/** Session-lifetime conversation log. Each stream() call replays from the start. */
-export declare class SessionEventLog implements AsyncIterable<SessionEvent<JsonValue>> {
-    private readonly events;
-    private readonly subscribers;
-    private done;
-    emit(event: SessionEvent<JsonValue>): void;
-    finish(): void;
-    [Symbol.asyncIterator](): AsyncIterator<SessionEvent<JsonValue>>;
-    private wake;
-}

package/dist/session/event-log.js

@@ -1,63 +0,0 @@
-/** Session-lifetime conversation log. Each stream() call replays from the start. */
-export class SessionEventLog {
-    events = [];
-    subscribers = [];
-    done = false;
-    emit(event) {
-        if (this.done)
-            return;
-        this.events.push(event);
-        this.wake();
-    }
-    finish() {
-        if (this.done)
-            return;
-        this.done = true;
-        this.wake();
-        this.subscribers.length = 0;
-    }
-    [Symbol.asyncIterator]() {
-        let index = 0;
-        let closed = false;
-        const waiting = [];
-        this.subscribers.push(waiting);
-        const detach = () => {
-            const position = this.subscribers.indexOf(waiting);
-            if (position !== -1)
-                this.subscribers.splice(position, 1);
-        };
-        const complete = () => {
-            closed = true;
-            detach();
-            return { done: true, value: undefined };
-        };
-        const pull = () => {
-            if (closed)
-                return Promise.resolve({ done: true, value: undefined });
-            if (index < this.events.length)
-                return Promise.resolve({ done: false, value: this.events[index++] });
-            if (this.done)
-                return Promise.resolve(complete());
-            return new Promise((resolve) => {
-                waiting.push(() => {
-                    void pull().then(resolve);
-                });
-            });
-        };
-        return {
-            next: pull,
-            return: () => {
-                const result = complete();
-                while (waiting.length)
-                    waiting.shift()();
-                return Promise.resolve(result);
-            },
-        };
-    }
-    wake() {
-        for (const waiting of this.subscribers) {
-            while (waiting.length)
-                waiting.shift()();
-        }
-    }
-}