@deepseek-harness-tui/dsh-tui 0.8.0 → 0.8.2

package/node_modules/@dsh-std/connection/lib/connection-CdGcSQnu.d.ts

@@ -0,0 +1,125 @@
+import { ApiReference, NegotiatedProtocol, ProtocolCatalog, ProtocolDeclaration, ProtocolRequirement, ProtocolSupport } from "@dsh-std/core";
+//#region src/model.d.ts
+declare const CONNECTION_API_VERSION = "connection.dsh/v1alpha1";
+interface EndpointIdentity {
+  readonly id: string;
+  readonly instanceId: string;
+}
+interface EndpointOffer {
+  readonly apiVersion: typeof CONNECTION_API_VERSION;
+  readonly kind: 'ConnectionOffer';
+  readonly endpoint: EndpointIdentity;
+  readonly revision: number;
+  readonly declarations: readonly ProtocolDeclaration[];
+}
+interface ConnectionEndpointReference extends EndpointIdentity {}
+interface CapabilityParticipant {
+  readonly endpoint: ConnectionEndpointReference;
+  readonly participantId: string;
+}
+interface CapabilityBinding {
+  readonly bindingId: string;
+  readonly agreementId: string;
+  readonly planRevision: number;
+  readonly consumer: CapabilityParticipant;
+  readonly provider: CapabilityParticipant;
+  readonly requirement: ProtocolRequirement;
+  readonly support: ProtocolSupport;
+}
+interface ConnectionIssue {
+  readonly severity: 'error' | 'warning';
+  readonly code: string;
+  readonly participant?: CapabilityParticipant;
+  readonly path?: string;
+  readonly message: string;
+}
+interface ConnectionPlan {
+  readonly apiVersion: typeof CONNECTION_API_VERSION;
+  readonly kind: 'ConnectionAgreement';
+  readonly connectionId: string;
+  readonly revision: number;
+  readonly digest: string;
+  readonly offers: readonly {
+    readonly endpoint: ConnectionEndpointReference;
+    readonly revision: number;
+  }[];
+  readonly compatible: boolean;
+  readonly protocols: readonly NegotiatedProtocol[];
+  readonly bindings: readonly CapabilityBinding[];
+  readonly issues: readonly ConnectionIssue[];
+}
+interface ResolveConnectionOptions {
+  readonly connectionId: string;
+  readonly revision: number;
+  readonly protocols: ProtocolCatalog;
+  readonly policy?: unknown;
+}
+/** Policy envelope supplied to definitions while evaluating a pair of endpoint offers. */
+interface ConnectionNegotiationPolicy {
+  readonly endpointByParticipant: Readonly<Record<string, string>>;
+  readonly protocol?: unknown;
+}
+declare function createEndpointOffer(endpoint: EndpointIdentity, revision: number, declarations: readonly ProtocolDeclaration[]): EndpointOffer;
+declare function validateEndpointOffer(offer: EndpointOffer): void;
+declare function freezeEndpoint(endpoint: EndpointIdentity): ConnectionEndpointReference;
+declare function validatePlanCoordinates(connectionId: string, revision: number): void;
+//#endregion
+//#region src/connection.d.ts
+interface CapabilityHandlerContext<TProgress = unknown> {
+  readonly connectionId: string;
+  readonly planRevision: number;
+  readonly invocationId: string;
+  readonly binding: CapabilityBinding;
+  readonly signal: AbortSignal;
+  progress(value: TProgress): void;
+}
+type CapabilityHandler<TInput = unknown, TOutput = unknown, TProgress = unknown> = (operation: string, input: TInput, context: CapabilityHandlerContext<TProgress>) => TOutput | Promise<TOutput>;
+interface CapabilityImplementation<TInput = unknown, TOutput = unknown, TProgress = unknown> {
+  readonly participantId: string;
+  readonly protocol: ProtocolSupport;
+  readonly handle: CapabilityHandler<TInput, TOutput, TProgress>;
+}
+interface CapabilityDispatch<TInput = unknown, TProgress = unknown> {
+  readonly connectionId: string;
+  readonly planRevision: number;
+  readonly invocationId: string;
+  readonly binding: CapabilityBinding;
+  readonly operation: string;
+  readonly input: TInput;
+  readonly signal: AbortSignal;
+  progress(value: TProgress): void;
+}
+interface ConnectionEndpoint {
+  readonly offer: EndpointOffer;
+  dispatch<TInput = unknown, TOutput = unknown, TProgress = unknown>(invocation: CapabilityDispatch<TInput, TProgress>): Promise<TOutput>;
+  onOfferChange(listener: (offer: EndpointOffer) => void): () => void;
+}
+interface CapabilityCall<TOutput = unknown, TProgress = unknown> {
+  readonly invocationId: string;
+  readonly result: Promise<TOutput>;
+  readonly progress: AsyncIterable<TProgress>;
+  cancel(reason?: string): void;
+}
+interface CapabilityClient {
+  readonly participantId: string;
+  binding(reference: ApiReference): CapabilityBinding | undefined;
+  invoke<TInput = unknown, TOutput = unknown, TProgress = unknown>(reference: ApiReference, operation: string, input: TInput, options?: {
+    readonly signal?: AbortSignal;
+  }): CapabilityCall<TOutput, TProgress>;
+}
+interface StandardConnection {
+  readonly id: string;
+  readonly local: ConnectionEndpointReference;
+  readonly remote: ConnectionEndpointReference;
+  readonly plan: ConnectionPlan;
+  client(participantId: string): CapabilityClient;
+  onPlanChange(listener: (plan: ConnectionPlan) => void): () => void;
+  close(reason?: string): void | Promise<void>;
+}
+declare class ConnectionInvocationError extends Error {
+  readonly code: 'connection-closed' | 'capability-unbound' | 'handler-missing' | 'cancelled' | 'handler-failed';
+  constructor(code: 'connection-closed' | 'capability-unbound' | 'handler-missing' | 'cancelled' | 'handler-failed', message: string, options?: ErrorOptions);
+}
+//#endregion
+export { validatePlanCoordinates as C, validateEndpointOffer as S, EndpointIdentity as _, CapabilityHandlerContext as a, createEndpointOffer as b, ConnectionInvocationError as c, CapabilityBinding as d, CapabilityParticipant as f, ConnectionPlan as g, ConnectionNegotiationPolicy as h, CapabilityHandler as i, StandardConnection as l, ConnectionIssue as m, CapabilityClient as n, CapabilityImplementation as o, ConnectionEndpointReference as p, CapabilityDispatch as r, ConnectionEndpoint as s, CapabilityCall as t, CONNECTION_API_VERSION as u, EndpointOffer as v, freezeEndpoint as x, ResolveConnectionOptions as y };
+//# sourceMappingURL=connection-CdGcSQnu.d.ts.map

package/node_modules/@dsh-std/connection/lib/connection-CdGcSQnu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-CdGcSQnu.d.ts","names":[],"sources":["../src/model.ts","../src/connection.ts"],"mappings":";;cASa;UAEI;WACN;WACA;;UAGM;WACN,mBAAmB;WACnB;WACA,UAAU;WACV;WACA,uBAAuB;;UAGjB,oCAAoC;UAEpC;WACN,UAAU;WACV;;UAGM;WACN;WACA;WACA;WACA,UAAU;WACV,UAAU;WACV,aAAa;WACb,SAAS;;UAGH;WACN;WACA;WACA,cAAc;WACd;WACA;;UAGM;WACN,mBAAmB;WACnB;WACA;WACA;WACA;WACA;aACE,UAAU;aACV;;WAEF;WACA,oBAAoB;WACpB,mBAAmB;WACnB,iBAAiB;;UAGX;WACN;WACA;WACA,WAAW;WACX;;;UAIM;WACN,uBAAuB,SAAS;WAChC;;iBAGK,oBACd,UAAU,kBACV,kBACA,uBAAuB,wBACtB;iBAkBa,sBAAsB,OAAO;iBAa7B,eAAe,UAAU,mBAAmB;iBAI5C,wBAAwB,sBAAsB;;;UClH7C,yBAAyB;WAC/B;WACA;WACA;WACA,SAAS;WACT,QAAQ;EACjB,SAAS,OAAO;;KAGN,kBAAkB,kBAAkB,mBAAmB,wBACjE,mBAAmB,OAAO,QAAQ,SAAS,yBAAyB,eACjE,UAAU,QAAQ;UAEN,yBAAyB,kBAAkB,mBAAmB;WACpE;WACA,UAAU;WACV,QAAQ,kBAAkB,QAAQ,SAAS;;UAGrC,mBAAmB,kBAAkB;WAC3C;WACA;WACA;WACA,SAAS;WACT;WACA,OAAO;WACP,QAAQ;EACjB,SAAS,OAAO;;UAGD;WACN,OAAO;EAChB,SAAS,kBAAkB,mBAAmB,qBAAqB,YAAY,mBAAmB,QAAQ,aAAa,QAAQ;EAC/H,cAAc,WAAW,OAAO;;UAGjB,eAAe,mBAAmB;WACxC;WACA,QAAQ,QAAQ;WAChB,UAAU,cAAc;EACjC,OAAO;;UAGQ;WACN;EACT,QAAQ,WAAW,eAAe;EAClC,OAAO,kBAAkB,mBAAmB,qBAC1C,WAAW,cACX,mBACA,OAAO,QACP;aAAqB,SAAS;MAC7B,eAAe,SAAS;;UAGZ;WACN;WACA,OAAO;WACP,QAAQ;WACR,MAAM;EACf,OAAO,wBAAwB;EAC/B,aAAa,WAAW,MAAM;EAC9B,MAAM,yBAAyB;;cAGpB,kCAAkC;WAElC;EAAA,YAAA,uGACT,iBACA,UAAU"}

package/node_modules/@dsh-std/connection/lib/index.d.ts

@@ -0,0 +1,89 @@
+import { C as validatePlanCoordinates, S as validateEndpointOffer, _ as EndpointIdentity, a as CapabilityHandlerContext, b as createEndpointOffer, c as ConnectionInvocationError, d as CapabilityBinding, f as CapabilityParticipant, g as ConnectionPlan, h as ConnectionNegotiationPolicy, i as CapabilityHandler, l as StandardConnection, m as ConnectionIssue, n as CapabilityClient, o as CapabilityImplementation, p as ConnectionEndpointReference, r as CapabilityDispatch, s as ConnectionEndpoint, t as CapabilityCall, u as CONNECTION_API_VERSION, v as EndpointOffer, x as freezeEndpoint, y as ResolveConnectionOptions } from "./connection-CdGcSQnu.js";
+import { ProtocolDeclaration, ProtocolDefinition, ProtocolRequirement, ProtocolSupport } from "@dsh-std/core";
+//#region src/broker.d.ts
+interface ConnectionTarget {
+  /** Implementation-neutral target. Its URI scheme is interpreted by registered connectors. */
+  readonly uri: string;
+  readonly metadata?: Readonly<Record<string, string>>;
+}
+interface ConnectRequest {
+  readonly target: ConnectionTarget;
+  /** Live endpoint, including the dispatcher used for peer-to-local calls. */
+  readonly local: ConnectionEndpoint;
+  readonly signal?: AbortSignal;
+}
+/** Client half of one concrete connection implementation. */
+interface ConnectionConnector {
+  /** Namespaced implementation identity, not a transport or product name exposed to domain consumers. */
+  readonly id: string;
+  supports(target: ConnectionTarget): boolean;
+  connect(request: ConnectRequest): Promise<StandardConnection>;
+}
+declare class ConnectionSelectionError extends Error {
+  readonly code: 'implementation-unavailable' | 'implementation-ambiguous';
+  readonly implementations: readonly string[];
+  constructor(code: 'implementation-unavailable' | 'implementation-ambiguous', message: string, implementations: readonly string[]);
+}
+/**
+ * Implementation registry used by an adapter or application composition root.
+ * Domain consumers request a connection; they never import the selected implementation.
+ */
+declare class ConnectionBroker {
+  private readonly connectors;
+  register(connector: ConnectionConnector): () => void;
+  implementations(target?: ConnectionTarget): readonly string[];
+  connect(request: ConnectRequest): Promise<StandardConnection>;
+}
+//#endregion
+//#region src/endpoint.d.ts
+interface EndpointPublication {
+  readonly declaration: ProtocolDeclaration;
+  readonly implementations?: readonly CapabilityImplementation[];
+}
+interface EndpointRuntimeOptions extends EndpointIdentity {
+  readonly revision?: number;
+}
+declare class StandardEndpointRuntime implements ConnectionEndpoint {
+  private readonly declarations;
+  private readonly implementations;
+  private readonly listeners;
+  private readonly identity;
+  private revision;
+  private currentOffer;
+  constructor(options: EndpointRuntimeOptions);
+  get offer(): EndpointOffer;
+  register(publication: EndpointPublication): () => void;
+  dispatch<TInput = unknown, TOutput = unknown, TProgress = unknown>(invocation: CapabilityDispatch<TInput, TProgress>): Promise<TOutput>;
+  onOfferChange(listener: (offer: EndpointOffer) => void): () => void;
+  private createOffer;
+  private publishOffer;
+}
+//#endregion
+//#region src/resolve.d.ts
+declare function resolveConnection(left: EndpointOffer, right: EndpointOffer, options: ResolveConnectionOptions): ConnectionPlan;
+//#endregion
+//#region src/rpc.d.ts
+interface CapabilityBindingDraft {
+  readonly consumer: string;
+  readonly provider: string;
+  readonly requirement: ProtocolRequirement;
+  readonly support: ProtocolSupport;
+}
+interface CapabilityAgreement {
+  readonly kind: 'CapabilityBindings';
+  readonly bindings: readonly CapabilityBindingDraft[];
+}
+interface CapabilityProtocolOptions {
+  readonly apiVersion: string;
+  readonly kind: string;
+  readonly accepts?: readonly string[];
+  readonly multipleProviders?: boolean;
+  validateRequirement?(spec: unknown): unknown;
+  validateSupport?(spec: unknown): unknown;
+}
+/** Reusable RPC-shaped protocol definition. Domain packages opt into these semantics explicitly. */
+declare function defineCapabilityProtocol(options: CapabilityProtocolOptions): ProtocolDefinition;
+declare function isCapabilityAgreement(value: unknown): value is CapabilityAgreement;
+//#endregion
+export { CONNECTION_API_VERSION, CapabilityAgreement, CapabilityBinding, CapabilityBindingDraft, CapabilityCall, CapabilityClient, CapabilityDispatch, CapabilityHandler, CapabilityHandlerContext, CapabilityImplementation, CapabilityParticipant, CapabilityProtocolOptions, ConnectRequest, ConnectionBroker, ConnectionConnector, ConnectionEndpoint, ConnectionEndpointReference, ConnectionInvocationError, ConnectionIssue, ConnectionNegotiationPolicy, ConnectionPlan, ConnectionSelectionError, ConnectionTarget, EndpointIdentity, EndpointOffer, EndpointPublication, EndpointRuntimeOptions, ResolveConnectionOptions, StandardConnection, StandardEndpointRuntime, createEndpointOffer, defineCapabilityProtocol, freezeEndpoint, isCapabilityAgreement, resolveConnection, validateEndpointOffer, validatePlanCoordinates };
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@dsh-std/connection/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/broker.ts","../src/endpoint.ts","../src/resolve.ts","../src/rpc.ts"],"mappings":";;;UAGiB;;WAEN;WACA,WAAW,SAAS;;UAGd;WACN,QAAQ;;WAER,OAAO;WACP,SAAS;;;UAIH;;WAEN;EACT,SAAS,QAAQ;EACjB,QAAQ,SAAS,iBAAiB,QAAQ;;cAG/B,iCAAiC;WAEjC;WAEA;EAFA,YAAA,iEACT,iBACS;;;;;;cAWA;mBACM;EAEjB,SAAS,WAAW;EAOpB,gBAAgB,SAAS;EAQnB,QAAQ,SAAS,iBAAiB,QAAQ;;;;UC3CjC;WACN,aAAa;WACb,2BAA2B;;UAGrB,+BAA+B;WACrC;;cAGE,mCAAmC;mBAC7B;mBACA;mBACA;mBACA;UACT;UACA;EAEI,YAAA,SAAS;MAMjB,SAAS;EAEb,SAAS,aAAa;EAmChB,SAAS,kBAAkB,mBAAmB,qBAAqB,YAAY,mBAAmB,QAAQ,aAAa,QAAQ;EAqBrI,cAAc,WAAW,OAAO;UAKxB;UAIA;;;;iBCxFM,kBAAkB,MAAM,eAAe,OAAO,eAAe,SAAS,2BAA2B;;;UCRhG;WACN;WACA;WACA,aAAa;WACb,SAAS;;UAGH;WACN;WACA,mBAAmB;;UAGb;WACN;WACA;WACA;WACA;EACT,qBAAqB;EACrB,iBAAiB;;;iBAIH,yBAAyB,SAAS,4BAA4B;iBA0D9D,sBAAsB,iBAAiB,SAAS"}

package/node_modules/@dsh-std/connection/lib/index.js

@@ -0,0 +1,158 @@
+import { a as CONNECTION_API_VERSION, c as validateEndpointOffer, i as ConnectionInvocationError, l as validatePlanCoordinates, n as defineCapabilityProtocol, o as createEndpointOffer, r as isCapabilityAgreement, s as freezeEndpoint, t as resolveConnection } from "./resolve-3X6ausgz.js";
+import { defineProtocolDeclaration, sameProtocol } from "@dsh-std/core";
+//#region src/broker.ts
+var ConnectionSelectionError = class extends Error {
+	code;
+	implementations;
+	constructor(code, message, implementations) {
+		super(message);
+		this.code = code;
+		this.implementations = implementations;
+		this.name = "ConnectionSelectionError";
+	}
+};
+/**
+* Implementation registry used by an adapter or application composition root.
+* Domain consumers request a connection; they never import the selected implementation.
+*/
+var ConnectionBroker = class {
+	connectors = /* @__PURE__ */ new Map();
+	register(connector) {
+		namespaced(connector.id, "connection connector id");
+		if (this.connectors.has(connector.id)) throw new Error(`connection connector ${JSON.stringify(connector.id)} is already registered`);
+		this.connectors.set(connector.id, connector);
+		return () => {
+			if (this.connectors.get(connector.id) === connector) this.connectors.delete(connector.id);
+		};
+	}
+	implementations(target) {
+		if (target !== void 0) validateTarget(target);
+		return Object.freeze([...this.connectors.values()].filter((connector) => target === void 0 || safelySupports(connector, target)).map((connector) => connector.id).sort());
+	}
+	async connect(request) {
+		validateTarget(request.target);
+		validateEndpointOffer(request.local.offer);
+		request.signal?.throwIfAborted();
+		const matches = [...this.connectors.values()].filter((connector) => safelySupports(connector, request.target)).sort((left, right) => left.id.localeCompare(right.id));
+		if (matches.length === 0) throw new ConnectionSelectionError("implementation-unavailable", `no connection implementation supports ${JSON.stringify(request.target.uri)}`, []);
+		if (matches.length > 1) {
+			const ids = Object.freeze(matches.map((connector) => connector.id));
+			throw new ConnectionSelectionError("implementation-ambiguous", `multiple connection implementations support ${JSON.stringify(request.target.uri)}: ${ids.join(", ")}`, ids);
+		}
+		return matches[0].connect(request);
+	}
+};
+function safelySupports(connector, target) {
+	try {
+		return connector.supports(target);
+	} catch {
+		return false;
+	}
+}
+function validateTarget(target) {
+	if (typeof target.uri !== "string" || target.uri.trim() === "") throw new TypeError("connection target uri must be non-empty");
+	if (target.metadata !== void 0) {
+		for (const [key, value] of Object.entries(target.metadata)) if (key.trim() === "" || typeof value !== "string") throw new TypeError("connection target metadata must contain string pairs");
+	}
+}
+function namespaced(value, label) {
+	if (!/^[a-z][a-z0-9]*(?:[.-][a-z0-9][a-z0-9-]*)+$/u.test(value)) throw new TypeError(`${label} must be namespaced`);
+}
+//#endregion
+//#region src/endpoint.ts
+var StandardEndpointRuntime = class {
+	declarations = /* @__PURE__ */ new Map();
+	implementations = [];
+	listeners = /* @__PURE__ */ new Set();
+	identity;
+	revision;
+	currentOffer;
+	constructor(options) {
+		this.identity = Object.freeze({
+			id: options.id,
+			instanceId: options.instanceId
+		});
+		this.revision = options.revision ?? 0;
+		this.currentOffer = this.createOffer();
+	}
+	get offer() {
+		return this.currentOffer;
+	}
+	register(publication) {
+		const declaration = defineProtocolDeclaration(publication.declaration);
+		const participantId = declaration.participant.id;
+		if (this.declarations.has(participantId)) throw new Error(`participant ${JSON.stringify(participantId)} is already registered`);
+		const implementations = [...publication.implementations ?? []];
+		const implemented = /* @__PURE__ */ new Set();
+		for (const implementation of implementations) {
+			if (implementation.participantId !== participantId) throw new TypeError(`implementation participantId must be ${JSON.stringify(participantId)}`);
+			if (!(declaration.supports ?? []).some((support) => sameProtocol(support, implementation.protocol))) throw new TypeError(`participant implementation ${implementation.protocol.apiVersion} ${implementation.protocol.kind} is not declared live`);
+			const key = `${implementation.protocol.apiVersion}\0${implementation.protocol.kind}`;
+			if (implemented.has(key)) throw new TypeError(`participant has multiple implementations for ${implementation.protocol.apiVersion} ${implementation.protocol.kind}`);
+			implemented.add(key);
+		}
+		const stored = implementations.map((implementation) => Object.freeze({
+			...implementation,
+			protocol: Object.freeze({ ...implementation.protocol }),
+			handle: implementation.handle
+		}));
+		this.declarations.set(participantId, declaration);
+		this.implementations.push(...stored);
+		this.publishOffer();
+		let active = true;
+		return () => {
+			if (!active) return;
+			active = false;
+			if (this.declarations.get(participantId) === declaration) this.declarations.delete(participantId);
+			for (const implementation of stored) {
+				const index = this.implementations.indexOf(implementation);
+				if (index >= 0) this.implementations.splice(index, 1);
+			}
+			this.publishOffer();
+		};
+	}
+	async dispatch(invocation) {
+		validateDispatch(invocation, this.currentOffer);
+		const implementation = this.implementations.find((candidate) => candidate.participantId === invocation.binding.provider.participantId && sameProtocol(candidate.protocol, invocation.binding.support));
+		if (implementation === void 0) throw new ConnectionInvocationError("handler-missing", `binding ${JSON.stringify(invocation.binding.bindingId)} has no live implementation`);
+		try {
+			return await implementation.handle(invocation.operation, invocation.input, Object.freeze({
+				connectionId: invocation.connectionId,
+				planRevision: invocation.planRevision,
+				invocationId: invocation.invocationId,
+				binding: invocation.binding,
+				signal: invocation.signal,
+				progress: invocation.progress
+			}));
+		} catch (error) {
+			if (error instanceof ConnectionInvocationError) throw error;
+			throw new ConnectionInvocationError("handler-failed", error instanceof Error ? error.message : String(error), { cause: error });
+		}
+	}
+	onOfferChange(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	createOffer() {
+		return createEndpointOffer(this.identity, this.revision, [...this.declarations.values()]);
+	}
+	publishOffer() {
+		this.revision += 1;
+		this.currentOffer = this.createOffer();
+		for (const listener of this.listeners) listener(this.currentOffer);
+	}
+};
+function validateDispatch(invocation, offer) {
+	if (invocation.connectionId.trim() === "") throw new TypeError("connectionId must be non-empty");
+	if (!Number.isSafeInteger(invocation.planRevision) || invocation.planRevision < 1) throw new TypeError("planRevision must be positive");
+	if (invocation.binding.planRevision !== invocation.planRevision) throw new ConnectionInvocationError("capability-unbound", "binding belongs to another plan revision");
+	if (invocation.binding.provider.endpoint.instanceId !== offer.endpoint.instanceId) throw new ConnectionInvocationError("capability-unbound", "binding provider belongs to another endpoint");
+	if (invocation.invocationId.trim() === "" || invocation.operation.trim() === "") throw new TypeError("invocationId and operation must be non-empty");
+	invocation.signal.throwIfAborted();
+}
+//#endregion
+export { CONNECTION_API_VERSION, ConnectionBroker, ConnectionInvocationError, ConnectionSelectionError, StandardEndpointRuntime, createEndpointOffer, defineCapabilityProtocol, freezeEndpoint, isCapabilityAgreement, resolveConnection, validateEndpointOffer, validatePlanCoordinates };
+
+//# sourceMappingURL=index.js.map

package/node_modules/@dsh-std/connection/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/broker.ts","../src/endpoint.ts"],"sourcesContent":["import { validateEndpointOffer } from './model.js'\nimport type { ConnectionEndpoint, StandardConnection } from './connection.js'\n\nexport interface ConnectionTarget {\n  /** Implementation-neutral target. Its URI scheme is interpreted by registered connectors. */\n  readonly uri: string\n  readonly metadata?: Readonly<Record<string, string>>\n}\n\nexport interface ConnectRequest {\n  readonly target: ConnectionTarget\n  /** Live endpoint, including the dispatcher used for peer-to-local calls. */\n  readonly local: ConnectionEndpoint\n  readonly signal?: AbortSignal\n}\n\n/** Client half of one concrete connection implementation. */\nexport interface ConnectionConnector {\n  /** Namespaced implementation identity, not a transport or product name exposed to domain consumers. */\n  readonly id: string\n  supports(target: ConnectionTarget): boolean\n  connect(request: ConnectRequest): Promise<StandardConnection>\n}\n\nexport class ConnectionSelectionError extends Error {\n  constructor(\n    readonly code: 'implementation-unavailable' | 'implementation-ambiguous',\n    message: string,\n    readonly implementations: readonly string[],\n  ) {\n    super(message)\n    this.name = 'ConnectionSelectionError'\n  }\n}\n\n/**\n * Implementation registry used by an adapter or application composition root.\n * Domain consumers request a connection; they never import the selected implementation.\n */\nexport class ConnectionBroker {\n  private readonly connectors = new Map<string, ConnectionConnector>()\n\n  register(connector: ConnectionConnector): () => void {\n    namespaced(connector.id, 'connection connector id')\n    if (this.connectors.has(connector.id)) throw new Error(`connection connector ${JSON.stringify(connector.id)} is already registered`)\n    this.connectors.set(connector.id, connector)\n    return () => { if (this.connectors.get(connector.id) === connector) this.connectors.delete(connector.id) }\n  }\n\n  implementations(target?: ConnectionTarget): readonly string[] {\n    if (target !== undefined) validateTarget(target)\n    return Object.freeze([...this.connectors.values()]\n      .filter(connector => target === undefined || safelySupports(connector, target))\n      .map(connector => connector.id)\n      .sort())\n  }\n\n  async connect(request: ConnectRequest): Promise<StandardConnection> {\n    validateTarget(request.target)\n    validateEndpointOffer(request.local.offer)\n    request.signal?.throwIfAborted()\n    const matches = [...this.connectors.values()]\n      .filter(connector => safelySupports(connector, request.target))\n      .sort((left, right) => left.id.localeCompare(right.id))\n    if (matches.length === 0) {\n      throw new ConnectionSelectionError(\n        'implementation-unavailable',\n        `no connection implementation supports ${JSON.stringify(request.target.uri)}`,\n        [],\n      )\n    }\n    if (matches.length > 1) {\n      const ids = Object.freeze(matches.map(connector => connector.id))\n      throw new ConnectionSelectionError(\n        'implementation-ambiguous',\n        `multiple connection implementations support ${JSON.stringify(request.target.uri)}: ${ids.join(', ')}`,\n        ids,\n      )\n    }\n    return matches[0]!.connect(request)\n  }\n}\n\nfunction safelySupports(connector: ConnectionConnector, target: ConnectionTarget): boolean {\n  try { return connector.supports(target) } catch { return false }\n}\n\nfunction validateTarget(target: ConnectionTarget): void {\n  if (typeof target.uri !== 'string' || target.uri.trim() === '') throw new TypeError('connection target uri must be non-empty')\n  if (target.metadata !== undefined) {\n    for (const [key, value] of Object.entries(target.metadata)) {\n      if (key.trim() === '' || typeof value !== 'string') throw new TypeError('connection target metadata must contain string pairs')\n    }\n  }\n}\n\nfunction namespaced(value: string, label: string): void {\n  if (!/^[a-z][a-z0-9]*(?:[.-][a-z0-9][a-z0-9-]*)+$/u.test(value)) throw new TypeError(`${label} must be namespaced`)\n}\n","import {\n  defineProtocolDeclaration,\n  sameProtocol,\n  type ProtocolDeclaration,\n  type ProtocolSupport,\n} from '@dsh-std/core'\nimport {\n  ConnectionInvocationError,\n  type CapabilityDispatch,\n  type CapabilityImplementation,\n  type ConnectionEndpoint,\n} from './connection.js'\nimport { createEndpointOffer, type EndpointIdentity, type EndpointOffer } from './model.js'\n\nexport interface EndpointPublication {\n  readonly declaration: ProtocolDeclaration\n  readonly implementations?: readonly CapabilityImplementation[]\n}\n\nexport interface EndpointRuntimeOptions extends EndpointIdentity {\n  readonly revision?: number\n}\n\nexport class StandardEndpointRuntime implements ConnectionEndpoint {\n  private readonly declarations = new Map<string, ProtocolDeclaration>()\n  private readonly implementations: CapabilityImplementation[] = []\n  private readonly listeners = new Set<(offer: EndpointOffer) => void>()\n  private readonly identity: EndpointIdentity\n  private revision: number\n  private currentOffer: EndpointOffer\n\n  constructor(options: EndpointRuntimeOptions) {\n    this.identity = Object.freeze({ id: options.id, instanceId: options.instanceId })\n    this.revision = options.revision ?? 0\n    this.currentOffer = this.createOffer()\n  }\n\n  get offer(): EndpointOffer { return this.currentOffer }\n\n  register(publication: EndpointPublication): () => void {\n    const declaration = defineProtocolDeclaration(publication.declaration)\n    const participantId = declaration.participant.id\n    if (this.declarations.has(participantId)) throw new Error(`participant ${JSON.stringify(participantId)} is already registered`)\n    const implementations = [...(publication.implementations ?? [])]\n    const implemented = new Set<string>()\n    for (const implementation of implementations) {\n      if (implementation.participantId !== participantId) throw new TypeError(`implementation participantId must be ${JSON.stringify(participantId)}`)\n      if (!(declaration.supports ?? []).some(support => sameProtocol(support, implementation.protocol))) {\n        throw new TypeError(`participant implementation ${implementation.protocol.apiVersion} ${implementation.protocol.kind} is not declared live`)\n      }\n      const key = `${implementation.protocol.apiVersion}\\0${implementation.protocol.kind}`\n      if (implemented.has(key)) throw new TypeError(`participant has multiple implementations for ${implementation.protocol.apiVersion} ${implementation.protocol.kind}`)\n      implemented.add(key)\n    }\n    const stored = implementations.map(implementation => Object.freeze({\n      ...implementation, protocol: Object.freeze({ ...implementation.protocol }),\n      handle: implementation.handle as CapabilityImplementation['handle'],\n    }))\n    this.declarations.set(participantId, declaration)\n    this.implementations.push(...stored)\n    this.publishOffer()\n    let active = true\n    return () => {\n      if (!active) return\n      active = false\n      if (this.declarations.get(participantId) === declaration) this.declarations.delete(participantId)\n      for (const implementation of stored) {\n        const index = this.implementations.indexOf(implementation)\n        if (index >= 0) this.implementations.splice(index, 1)\n      }\n      this.publishOffer()\n    }\n  }\n\n  async dispatch<TInput = unknown, TOutput = unknown, TProgress = unknown>(invocation: CapabilityDispatch<TInput, TProgress>): Promise<TOutput> {\n    validateDispatch(invocation, this.currentOffer)\n    const implementation = this.implementations.find(candidate =>\n      candidate.participantId === invocation.binding.provider.participantId\n      && sameProtocol(candidate.protocol, invocation.binding.support))\n    if (implementation === undefined) throw new ConnectionInvocationError('handler-missing', `binding ${JSON.stringify(invocation.binding.bindingId)} has no live implementation`)\n    try {\n      return await implementation.handle(invocation.operation, invocation.input, Object.freeze({\n        connectionId: invocation.connectionId,\n        planRevision: invocation.planRevision,\n        invocationId: invocation.invocationId,\n        binding: invocation.binding,\n        signal: invocation.signal,\n        progress: invocation.progress,\n      })) as TOutput\n    } catch (error) {\n      if (error instanceof ConnectionInvocationError) throw error\n      throw new ConnectionInvocationError('handler-failed', error instanceof Error ? error.message : String(error), { cause: error })\n    }\n  }\n\n  onOfferChange(listener: (offer: EndpointOffer) => void): () => void {\n    this.listeners.add(listener)\n    return () => { this.listeners.delete(listener) }\n  }\n\n  private createOffer(): EndpointOffer {\n    return createEndpointOffer(this.identity, this.revision, [...this.declarations.values()])\n  }\n\n  private publishOffer(): void {\n    this.revision += 1\n    this.currentOffer = this.createOffer()\n    for (const listener of this.listeners) listener(this.currentOffer)\n  }\n}\n\nfunction validateDispatch(invocation: CapabilityDispatch, offer: EndpointOffer): void {\n  if (invocation.connectionId.trim() === '') throw new TypeError('connectionId must be non-empty')\n  if (!Number.isSafeInteger(invocation.planRevision) || invocation.planRevision < 1) throw new TypeError('planRevision must be positive')\n  if (invocation.binding.planRevision !== invocation.planRevision) throw new ConnectionInvocationError('capability-unbound', 'binding belongs to another plan revision')\n  if (invocation.binding.provider.endpoint.instanceId !== offer.endpoint.instanceId) throw new ConnectionInvocationError('capability-unbound', 'binding provider belongs to another endpoint')\n  if (invocation.invocationId.trim() === '' || invocation.operation.trim() === '') throw new TypeError('invocationId and operation must be non-empty')\n  invocation.signal.throwIfAborted()\n}\n"],"mappings":"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"}

package/node_modules/@dsh-std/connection/lib/memory.d.ts

@@ -0,0 +1,24 @@
+import { g as ConnectionPlan, l as StandardConnection, o as CapabilityImplementation, r as CapabilityDispatch, s as ConnectionEndpoint, v as EndpointOffer, y as ResolveConnectionOptions } from "./connection-CdGcSQnu.js";
+//#region src/memory.d.ts
+declare class MemoryConnectionEndpoint implements ConnectionEndpoint {
+  private currentOffer;
+  private readonly implementations;
+  private readonly offerListeners;
+  constructor(offer: EndpointOffer);
+  get offer(): EndpointOffer;
+  replaceOffer(offer: EndpointOffer): void;
+  register(implementation: CapabilityImplementation): () => void;
+  dispatch<TInput = unknown, TOutput = unknown, TProgress = unknown>(invocation: CapabilityDispatch<TInput, TProgress>): Promise<TOutput>;
+  onOfferChange(listener: (offer: EndpointOffer) => void): () => void;
+}
+interface MemoryConnectionPair {
+  readonly left: StandardConnection;
+  readonly right: StandardConnection;
+  readonly plan: ConnectionPlan;
+  renegotiate(options: ResolveConnectionOptions): ConnectionPlan;
+  close(reason?: string): void;
+}
+declare function createMemoryConnectionPair(left: ConnectionEndpoint, right: ConnectionEndpoint, options: ResolveConnectionOptions): MemoryConnectionPair;
+//#endregion
+export { MemoryConnectionEndpoint, MemoryConnectionPair, createMemoryConnectionPair };
+//# sourceMappingURL=memory.d.ts.map

package/node_modules/@dsh-std/connection/lib/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","names":[],"sources":["../src/memory.ts"],"mappings":";;cAmBa,oCAAoC;UACvC;mBACS;mBACA;EAEL,YAAA,OAAO;MAKf,SAAS;EAEb,aAAa,OAAO;EAQpB,SAAS,gBAAgB;EAgBnB,SAAS,kBAAkB,mBAAmB,qBAAqB,YAAY,mBAAmB,QAAQ,aAAa,QAAQ;EAerI,cAAc,WAAW,OAAO;;UAMjB;WACN,MAAM;WACN,OAAO;WACP,MAAM;EACf,YAAY,SAAS,2BAA2B;EAChD,MAAM;;iBAGQ,2BACd,MAAM,oBAAoB,OAAO,oBAAoB,SAAS,2BAC7D"}