@agimon-ai/po-core 0.0.0-alpha.2 → 0.0.0-alpha.21

package/dist/src/schemas/protocolContracts.mjs

@@ -0,0 +1,164 @@
+import { ChordError, createHost, isChordError, method } from "@earendil-works/chord";
+//#region src/schemas/protocolContracts.ts
+/** Name of the Po server host; every Po contract places its objects on it. */
+const PO_SERVER_HOST = "server";
+/** Chord method specs for a schema table, typed so contracts built from them stay nameable. */
+function chordMethods(schemas) {
+	return Object.fromEntries(Object.entries(schemas).map(([name, { args, result }]) => [name, result !== void 0 ? method(args, result) : args !== void 0 ? method(args) : method()]));
+}
+/**
+* A Chord link over any ordered text transport. Feed received text to `deliver` and the
+* transport's end to `ended`.
+*/
+function createTextLink(port) {
+	let handler;
+	let queue = [];
+	const closeHandlers = /* @__PURE__ */ new Set();
+	let closed = false;
+	const ended = (reason) => {
+		if (closed) return;
+		closed = true;
+		queue = [];
+		try {
+			port.close();
+		} finally {
+			for (const close of closeHandlers) close(reason);
+			closeHandlers.clear();
+		}
+	};
+	const link = {
+		get closed() {
+			return closed;
+		},
+		send(frame) {
+			if (closed) return void 0;
+			const text = JSON.stringify(frame);
+			port.send(text);
+			return text.length;
+		},
+		receive(next) {
+			handler = next;
+			for (const frame of queue.splice(0)) next(frame);
+		},
+		onClose(close) {
+			if (closed) close("closed");
+			else closeHandlers.add(close);
+		},
+		close(reason = "closed") {
+			if (closed) return;
+			try {
+				port.send(JSON.stringify({
+					t: "bye",
+					reason
+				}));
+			} catch {}
+			ended(reason);
+		}
+	};
+	return {
+		link,
+		deliver(text) {
+			if (closed) return;
+			let frame;
+			try {
+				frame = JSON.parse(text);
+				if (frame === null || typeof frame !== "object" || typeof frame.t !== "string") throw new TypeError("not a frame");
+			} catch {
+				link.close("protocol error");
+				return;
+			}
+			if (frame.t === "bye") {
+				ended(frame.reason ?? "peer closed");
+				return;
+			}
+			if (handler === void 0) queue.push(frame);
+			else handler(frame);
+		},
+		ended
+	};
+}
+/**
+* Whether `error` means this client's code is older than the server's. Chord refuses a changed contract with
+* `contract_mismatch`, which it reports to a client as `upgrade_required`; another protocol version is reported the
+* same way by `createProtocolClient`. Retrying cannot help, only new client code can.
+*/
+function isUpdateRequired(error) {
+	return isChordError(error, "contract_mismatch") || isChordError(error, "upgrade_required");
+}
+function createProtocolClient(options) {
+	const host = createHost({
+		name: options.name ?? "client",
+		kind: "client",
+		self: { host: true }
+	});
+	const listeners = /* @__PURE__ */ new Set();
+	let current;
+	let connecting;
+	let disposed = false;
+	let updateError;
+	const emit = (state) => {
+		for (const listener of Array.from(listeners)) listener({ state });
+	};
+	const reportError = (error) => {
+		if (disposed || updateError !== void 0 || !isUpdateRequired(error)) return;
+		updateError = error;
+		emit("update_required");
+		current?.close();
+	};
+	return {
+		host,
+		get connected() {
+			return current !== void 0 && !current.closed;
+		},
+		get updateRequired() {
+			return updateError !== void 0;
+		},
+		connect() {
+			if (disposed) return Promise.reject(/* @__PURE__ */ new Error("The protocol client is disposed."));
+			if (updateError !== void 0) return Promise.reject(updateError);
+			if (current !== void 0 && !current.closed) return Promise.resolve();
+			connecting ??= (async () => {
+				try {
+					const link = await options.openLink();
+					if (disposed) {
+						link.close();
+						throw new Error("The protocol client is disposed.");
+					}
+					current = link;
+					link.onClose(() => {
+						if (current !== link) return;
+						current = void 0;
+						emit("disconnected");
+					});
+					host.connect(link, {
+						principal: { host: PO_SERVER_HOST },
+						onProtocolMismatch: ({ local, peer }) => reportError(new ChordError("upgrade_required", `The Po server speaks Chord protocol ${peer}, this client speaks ${local}.`))
+					});
+					if (!link.closed) emit("connected");
+				} finally {
+					connecting = void 0;
+				}
+			})();
+			return connecting;
+		},
+		disconnect() {
+			current?.close();
+		},
+		reportError,
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			current?.close();
+			listeners.clear();
+			host.close().catch(() => void 0);
+		},
+		onConnectionStateChange(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		}
+	};
+}
+//#endregion
+export { PO_SERVER_HOST, chordMethods, createProtocolClient, createTextLink, isUpdateRequired };
+
+//# sourceMappingURL=protocolContracts.mjs.map

package/dist/src/schemas/protocolContracts.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocolContracts.mjs","names":[],"sources":["../../../src/schemas/protocolContracts.ts"],"sourcesContent":["import { ChordError, createHost, isChordError, method, type Frame, type Host, type Link } from '@earendil-works/chord';\nimport type { TSchema } from 'typebox';\n\n/** Name of the Po server host; every Po contract places its objects on it. */\nexport const PO_SERVER_HOST = 'server';\n\n/** One method's argument and result schemas; a missing one means no arguments or a void result. */\nexport interface PoMethodSchemas {\n  readonly args?: TSchema;\n  readonly result?: TSchema;\n}\n\n/**\n * What Chord's `method(args, result)` returns. Chord keeps `MethodSpec` private, so declaration\n * emit cannot name an inferred `method()` result; this alias can.\n */\nexport type ChordMethod<A extends TSchema | undefined, R extends TSchema | undefined> = Omit<\n  ReturnType<typeof method<TSchema, TSchema>>,\n  'args' | 'result'\n> & { readonly args: A; readonly result: R };\n\nexport type ChordMethods<T extends Record<string, PoMethodSchemas>> = {\n  [K in keyof T]: ChordMethod<\n    T[K] extends { readonly args: infer A extends TSchema } ? A : undefined,\n    T[K] extends { readonly result: infer R extends TSchema } ? R : undefined\n  >;\n};\n\n/** Chord method specs for a schema table, typed so contracts built from them stay nameable. */\nexport function chordMethods<T extends Record<string, PoMethodSchemas>>(schemas: T): ChordMethods<T> {\n  return Object.fromEntries(\n    Object.entries<PoMethodSchemas>(schemas).map(([name, { args, result }]) => [\n      name,\n      result !== undefined ? method(args, result) : args !== undefined ? method(args) : method(),\n    ]),\n  ) as ChordMethods<T>;\n}\n\n/** A transport that carries text messages in order; `send` may be asynchronous (sealing). */\nexport interface TextPort {\n  send(text: string): void;\n  close(): void;\n}\n\n/**\n * A Chord link over any ordered text transport. Feed received text to `deliver` and the\n * transport's end to `ended`.\n */\nexport function createTextLink(port: TextPort): {\n  link: Link;\n  deliver(text: string): void;\n  ended(reason: string): void;\n} {\n  let handler: ((frame: Frame) => void) | undefined;\n  let queue: Frame[] = [];\n  const closeHandlers = new Set<(reason: string) => void>();\n  let closed = false;\n  const ended = (reason: string): void => {\n    if (closed) return;\n    closed = true;\n    queue = [];\n    try {\n      port.close();\n    } finally {\n      for (const close of closeHandlers) close(reason);\n      closeHandlers.clear();\n    }\n  };\n  const link: Link = {\n    get closed() {\n      return closed;\n    },\n    send(frame) {\n      if (closed) return undefined;\n      const text = JSON.stringify(frame);\n      port.send(text);\n      // Reported like Chord's WebSocket link, so this link joins its flow control.\n      return text.length;\n    },\n    receive(next) {\n      handler = next;\n      for (const frame of queue.splice(0)) next(frame);\n    },\n    onClose(close) {\n      if (closed) close('closed');\n      else closeHandlers.add(close);\n    },\n    close(reason = 'closed') {\n      if (closed) return;\n      try {\n        port.send(JSON.stringify({ t: 'bye', reason }));\n      } catch {\n        // The transport may already be gone.\n      }\n      ended(reason);\n    },\n  };\n  return {\n    link,\n    deliver(text) {\n      if (closed) return;\n      let frame: Frame;\n      try {\n        frame = JSON.parse(text) as Frame;\n        if (frame === null || typeof frame !== 'object' || typeof (frame as { t?: unknown }).t !== 'string')\n          throw new TypeError('not a frame');\n      } catch {\n        link.close('protocol error');\n        return;\n      }\n      if ((frame as { t: string }).t === 'bye') {\n        ended((frame as { reason?: string }).reason ?? 'peer closed');\n        return;\n      }\n      if (handler === undefined) queue.push(frame);\n      else handler(frame);\n    },\n    ended,\n  };\n}\n\n/**\n * Whether `error` means this client's code is older than the server's. Chord refuses a changed contract with\n * `contract_mismatch`, which it reports to a client as `upgrade_required`; another protocol version is reported the\n * same way by `createProtocolClient`. Retrying cannot help, only new client code can.\n */\nexport function isUpdateRequired(error: unknown): boolean {\n  return isChordError(error, 'contract_mismatch') || isChordError(error, 'upgrade_required');\n}\n\n/** `update_required` is heard once, before the closing link's `disconnected`; the client never connects again. */\nexport type ProtocolConnectionState = 'connected' | 'disconnected' | 'update_required';\n\n/** A browser or native Chord client host with one reconnectable link to the Po server. */\nexport interface ProtocolClient {\n  readonly host: Host;\n  readonly connected: boolean;\n  /** The server needs newer client code; `connect` rejects from now on. */\n  readonly updateRequired: boolean;\n  connect(): Promise<void>;\n  /** Closes the current link; listeners hear `disconnected`. */\n  disconnect(): void;\n  /** Hands over the error a held reference ended with; an update-required error stops the client for good. */\n  reportError(error: unknown): void;\n  dispose(): void;\n  onConnectionStateChange(listener: (change: { state: ProtocolConnectionState }) => void): () => void;\n}\n\nexport function createProtocolClient(options: { name?: string; openLink: () => Promise<Link> }): ProtocolClient {\n  const host = createHost({ name: options.name ?? 'client', kind: 'client', self: { host: true } });\n  const listeners = new Set<(change: { state: ProtocolConnectionState }) => void>();\n  let current: Link | undefined;\n  let connecting: Promise<void> | undefined;\n  let disposed = false;\n  let updateError: unknown;\n  const emit = (state: ProtocolConnectionState) => {\n    for (const listener of Array.from(listeners)) listener({ state });\n  };\n  const reportError = (error: unknown): void => {\n    if (disposed || updateError !== undefined || !isUpdateRequired(error)) return;\n    updateError = error;\n    emit('update_required');\n    current?.close();\n  };\n  return {\n    host,\n    get connected() {\n      return current !== undefined && !current.closed;\n    },\n    get updateRequired() {\n      return updateError !== undefined;\n    },\n    connect() {\n      if (disposed) return Promise.reject(new Error('The protocol client is disposed.'));\n      if (updateError !== undefined) return Promise.reject(updateError);\n      if (current !== undefined && !current.closed) return Promise.resolve();\n      connecting ??= (async () => {\n        try {\n          const link = await options.openLink();\n          if (disposed) {\n            link.close();\n            throw new Error('The protocol client is disposed.');\n          }\n          current = link;\n          link.onClose(() => {\n            if (current !== link) return;\n            current = undefined;\n            emit('disconnected');\n          });\n          host.connect(link, {\n            principal: { host: PO_SERVER_HOST },\n            onProtocolMismatch: ({ local, peer }) =>\n              reportError(\n                new ChordError(\n                  'upgrade_required',\n                  `The Po server speaks Chord protocol ${peer}, this client speaks ${local}.`,\n                ),\n              ),\n          });\n          if (!link.closed) emit('connected');\n        } finally {\n          connecting = undefined;\n        }\n      })();\n      return connecting;\n    },\n    disconnect() {\n      current?.close();\n    },\n    reportError,\n    dispose() {\n      if (disposed) return;\n      disposed = true;\n      current?.close();\n      listeners.clear();\n      void host.close().catch(() => undefined);\n    },\n    onConnectionStateChange(listener) {\n      listeners.add(listener);\n      return () => listeners.delete(listener);\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/src/schemas/protocolHubContract.cjs

@@ -0,0 +1,51 @@
+const require_protocolContracts = require("./protocolContracts.cjs");
+const require_httpApiContracts = require("./httpApiContracts.cjs");
+const require_pluginProtocol = require("./pluginProtocol.cjs");
+let typebox = require("typebox");
+let dist_interop_chord_mjs = require("../../../dist/interop/chord.mjs");
+//#region src/schemas/protocolHubContract.ts
+const Text = typebox.Type.String();
+const Json = typebox.Type.Unsafe({});
+/** A live session frame every hub client needs (notification entries and agent dialogs) until it is acknowledged. */
+const HubNoticeSchema = typebox.Type.Object({
+	id: Text,
+	sessionId: Text,
+	frame: typebox.Type.Record(Text, Json)
+});
+const HubState = {
+	sessions: typebox.Type.Record(Text, require_httpApiContracts.SessionSummarySchema),
+	workspaces: typebox.Type.Record(Text, require_httpApiContracts.WorkspaceSchema),
+	pending: typebox.Type.Array(HubNoticeSchema)
+};
+const PoHubStateSchema = typebox.Type.Object(HubState);
+/** What one connection may see: its sessions, its workspaces, and the notices it has not acknowledged. */
+const PoHubContract = (0, dist_interop_chord_mjs.remote)("po.hub", {
+	version: 1,
+	host: (0, dist_interop_chord_mjs.hostNamed)(require_protocolContracts.PO_SERVER_HOST),
+	input: typebox.Type.Object({}),
+	variants: { default: {
+		state: HubState,
+		methods: require_protocolContracts.chordMethods({
+			readHome: {
+				args: typebox.Type.Object({
+					offset: typebox.Type.Optional(typebox.Type.Integer({ minimum: 0 })),
+					limit: typebox.Type.Optional(typebox.Type.Integer({ minimum: 1 })),
+					source: typebox.Type.Optional(Text),
+					workspaceId: typebox.Type.Optional(Text)
+				}),
+				result: typebox.Type.Unsafe({})
+			},
+			invoke: {
+				args: require_pluginProtocol.PoPluginCallSchema,
+				result: Json
+			},
+			ackNotice: { args: typebox.Type.Object({ id: Text }) }
+		})
+	} }
+});
+//#endregion
+exports.HubNoticeSchema = HubNoticeSchema;
+exports.PoHubContract = PoHubContract;
+exports.PoHubStateSchema = PoHubStateSchema;
+
+//# sourceMappingURL=protocolHubContract.cjs.map

package/dist/src/schemas/protocolHubContract.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocolHubContract.cjs","names":["Type","SessionSummarySchema","WorkspaceSchema","remote","hostNamed","PO_SERVER_HOST","chordMethods","PoPluginCallSchema"],"sources":["../../../src/schemas/protocolHubContract.ts"],"sourcesContent":["import { hostNamed, remote, type Ref } from '@earendil-works/chord';\nimport { Type, type Static } from 'typebox';\n\nimport type { HomeSnapshot } from './home';\nimport { SessionSummarySchema, WorkspaceSchema } from './httpApiContracts';\nimport { PoPluginCallSchema } from './pluginProtocol';\nimport { chordMethods, PO_SERVER_HOST } from './protocolContracts';\nimport type { JsonValue } from './sessionProtocol';\n\nconst Text = Type.String();\nconst Json = Type.Unsafe<JsonValue>({});\n\n/** A live session frame every hub client needs (notification entries and agent dialogs) until it is acknowledged. */\nexport const HubNoticeSchema = Type.Object({ id: Text, sessionId: Text, frame: Type.Record(Text, Json) });\nexport type HubNotice = Static<typeof HubNoticeSchema>;\nexport type HubSessionView = Static<typeof SessionSummarySchema>;\nexport type HubWorkspaceView = Static<typeof WorkspaceSchema>;\n\nconst HubState = {\n  sessions: Type.Record(Text, SessionSummarySchema),\n  workspaces: Type.Record(Text, WorkspaceSchema),\n  pending: Type.Array(HubNoticeSchema),\n};\nexport const PoHubStateSchema = Type.Object(HubState);\n\n/** What one connection may see: its sessions, its workspaces, and the notices it has not acknowledged. */\nexport const PoHubContract = remote('po.hub', {\n  version: 1,\n  host: hostNamed(PO_SERVER_HOST),\n  input: Type.Object({}),\n  variants: {\n    default: {\n      state: HubState,\n      methods: chordMethods({\n        readHome: {\n          args: Type.Object({\n            offset: Type.Optional(Type.Integer({ minimum: 0 })),\n            limit: Type.Optional(Type.Integer({ minimum: 1 })),\n            source: Type.Optional(Text),\n            workspaceId: Type.Optional(Text),\n          }),\n          result: Type.Unsafe<HomeSnapshot>({}),\n        },\n        invoke: { args: PoPluginCallSchema, result: Json },\n        ackNotice: { args: Type.Object({ id: Text }) },\n      }),\n    },\n  },\n});\n\nexport type HubRef = Ref<typeof PoHubContract>;\n"],"mappings":";;;;;;AASA,MAAM,OAAOA,QAAAA,KAAK,OAAO;AACzB,MAAM,OAAOA,QAAAA,KAAK,OAAkB,CAAC,CAAC;;AAGtC,MAAa,kBAAkBA,QAAAA,KAAK,OAAO;CAAE,IAAI;CAAM,WAAW;CAAM,OAAOA,QAAAA,KAAK,OAAO,MAAM,IAAI;AAAE,CAAC;AAKxG,MAAM,WAAW;CACf,UAAUA,QAAAA,KAAK,OAAO,MAAMC,yBAAAA,oBAAoB;CAChD,YAAYD,QAAAA,KAAK,OAAO,MAAME,yBAAAA,eAAe;CAC7C,SAASF,QAAAA,KAAK,MAAM,eAAe;AACrC;AACA,MAAa,mBAAmBA,QAAAA,KAAK,OAAO,QAAQ;;AAGpD,MAAa,iBAAA,GAAgBG,uBAAAA,OAAAA,CAAO,UAAU;CAC5C,SAAS;CACT,OAAA,GAAMC,uBAAAA,UAAAA,CAAUC,0BAAAA,cAAc;CAC9B,OAAOL,QAAAA,KAAK,OAAO,CAAC,CAAC;CACrB,UAAU,EACR,SAAS;EACP,OAAO;EACP,SAASM,0BAAAA,aAAa;GACpB,UAAU;IACR,MAAMN,QAAAA,KAAK,OAAO;KAChB,QAAQA,QAAAA,KAAK,SAASA,QAAAA,KAAK,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;KAClD,OAAOA,QAAAA,KAAK,SAASA,QAAAA,KAAK,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;KACjD,QAAQA,QAAAA,KAAK,SAAS,IAAI;KAC1B,aAAaA,QAAAA,KAAK,SAAS,IAAI;IACjC,CAAC;IACD,QAAQA,QAAAA,KAAK,OAAqB,CAAC,CAAC;GACtC;GACA,QAAQ;IAAE,MAAMO,uBAAAA;IAAoB,QAAQ;GAAK;GACjD,WAAW,EAAE,MAAMP,QAAAA,KAAK,OAAO,EAAE,IAAI,KAAK,CAAC,EAAE;EAC/C,CAAC;CACH,EACF;AACF,CAAC"}

package/dist/src/schemas/protocolHubContract.d.mts

@@ -0,0 +1,218 @@
+import { JsonValue as JsonValue$1 } from "./sessionProtocol.mjs";
+import { HomeSnapshot } from "./home.mjs";
+import { ChordMethods } from "./protocolContracts.mjs";
+import { SessionSummarySchema, WorkspaceSchema } from "./httpApiContracts.mjs";
+import { Static, Type } from "typebox";
+import { Ref } from "@earendil-works/chord";
+//#region src/schemas/protocolHubContract.d.ts
+/** A live session frame every hub client needs (notification entries and agent dialogs) until it is acknowledged. */
+export declare const HubNoticeSchema: Type.TObject<{
+  id: Type.TString;
+  sessionId: Type.TString;
+  frame: Type.TRecord<"^.*$", Type.TUnsafe<JsonValue$1>>;
+}>;
+export type HubNotice = Static<typeof HubNoticeSchema>;
+export type HubSessionView = Static<typeof SessionSummarySchema>;
+export type HubWorkspaceView = Static<typeof WorkspaceSchema>;
+export declare const PoHubStateSchema: Type.TObject<{
+  sessions: Type.TRecord<"^.*$", Type.TObject<{
+    id: Type.TString;
+    workspaceId: Type.TOptional<Type.TString>;
+    webComposition: Type.TOptional<Type.TObject<{
+      id: Type.TString;
+      scope: Type.TUnion<[Type.TLiteral<"global">, Type.TLiteral<"workspace">, Type.TLiteral<"session">]>;
+      revision: Type.TNumber;
+      manifestUrl: Type.TString;
+      rawAssetBaseUrl: Type.TString;
+      verifiedAssetBaseUrl: Type.TString;
+      pluginEntries: Type.TArray<Type.TTuple<[Type.TString, Type.TString]>>;
+      assetPaths: Type.TArray<Type.TString>;
+      stylePaths: Type.TArray<Type.TString>;
+      channels: Type.TArray<Type.TString>;
+    }>>;
+    nativeComposition: Type.TOptional<Type.TObject<{
+      id: Type.TString;
+      scope: Type.TUnion<[Type.TLiteral<"global">, Type.TLiteral<"workspace">, Type.TLiteral<"session">]>;
+      revision: Type.TNumber;
+      manifestUrl: Type.TString;
+      rawAssetBaseUrl: Type.TString;
+      entryPath: Type.TString;
+      channels: Type.TArray<Type.TString>;
+      plugins: Type.TArray<Type.TString>;
+    }>>;
+    name: Type.TString;
+    cwd: Type.TString;
+    createdAt: Type.TString;
+    updatedAt: Type.TString;
+    phase: Type.TUnion<[Type.TLiteral<"idle">, Type.TLiteral<"turn">, Type.TLiteral<"compaction">, Type.TLiteral<"retry">]>;
+    phaseSince: Type.TString;
+    attach: Type.TLiteral<"attached">;
+    pendingMessageCount: Type.TNumber;
+    everPrompted: Type.TBoolean;
+    awaitingInput: Type.TBoolean;
+    lastSettledAt: Type.TOptional<Type.TString>;
+    git: Type.TOptional<Type.TObject<{
+      branch: Type.TString;
+      dirty: Type.TBoolean;
+    }>>;
+    profile: Type.TOptional<Type.TObject<{
+      name: Type.TString;
+      displayName: Type.TOptional<Type.TString>;
+      iconVersion: Type.TOptional<Type.TString>;
+    }>>;
+    parentSessionId: Type.TOptional<Type.TString>;
+    sessionProvenance: Type.TOptional<Type.TString>;
+    activity: Type.TOptional<Type.TObject<{
+      label: Type.TString;
+      attention: Type.TOptional<Type.TBoolean>;
+      since: Type.TOptional<Type.TString>;
+    }>>;
+    pendingSetups: Type.TOptional<Type.TArray<Type.TObject<{
+      id: Type.TString;
+      name: Type.TString;
+      createdAt: Type.TString;
+      cwd: Type.TOptional<Type.TString>;
+      setupKind: Type.TOptional<Type.TUnion<[Type.TLiteral<"managed-worktree">, Type.TLiteral<"existing-directory">]>>;
+      status: Type.TOptional<Type.TUnion<[Type.TLiteral<"provisioning">, Type.TLiteral<"failed">, Type.TLiteral<"interrupted">]>>;
+      errorCode: Type.TOptional<Type.TUnion<[Type.TLiteral<"SESSION_WORKTREE_PROVISION_FAILED">, Type.TLiteral<"SESSION_UNAVAILABLE">]>>;
+    }>>>;
+    groups: Type.TOptional<Type.TArray<Type.TString>>;
+    backgroundWorkActive: Type.TOptional<Type.TBoolean>;
+    dormant: Type.TOptional<Type.TBoolean>;
+  }>>;
+  workspaces: Type.TRecord<"^.*$", Type.TObject<{
+    id: Type.TString;
+    root: Type.TString;
+    name: Type.TOptional<Type.TString>;
+    available: Type.TOptional<Type.TBoolean>;
+  }>>;
+  pending: Type.TArray<Type.TObject<{
+    id: Type.TString;
+    sessionId: Type.TString;
+    frame: Type.TRecord<"^.*$", Type.TUnsafe<JsonValue$1>>;
+  }>>;
+}>;
+/** What one connection may see: its sessions, its workspaces, and the notices it has not acknowledged. */
+export declare const PoHubContract: import("@earendil-works/chord").RemoteContract<{
+  readonly version: 1;
+  readonly host: import("@earendil-works/chord").HostNamed;
+  readonly input: Type.TObject<{}>;
+  readonly variants: {
+    default: {
+      state: {
+        sessions: Type.TRecord<"^.*$", Type.TObject<{
+          id: Type.TString;
+          workspaceId: Type.TOptional<Type.TString>;
+          webComposition: Type.TOptional<Type.TObject<{
+            id: Type.TString;
+            scope: Type.TUnion<[Type.TLiteral<"global">, Type.TLiteral<"workspace">, Type.TLiteral<"session">]>;
+            revision: Type.TNumber;
+            manifestUrl: Type.TString;
+            rawAssetBaseUrl: Type.TString;
+            verifiedAssetBaseUrl: Type.TString;
+            pluginEntries: Type.TArray<Type.TTuple<[Type.TString, Type.TString]>>;
+            assetPaths: Type.TArray<Type.TString>;
+            stylePaths: Type.TArray<Type.TString>;
+            channels: Type.TArray<Type.TString>;
+          }>>;
+          nativeComposition: Type.TOptional<Type.TObject<{
+            id: Type.TString;
+            scope: Type.TUnion<[Type.TLiteral<"global">, Type.TLiteral<"workspace">, Type.TLiteral<"session">]>;
+            revision: Type.TNumber;
+            manifestUrl: Type.TString;
+            rawAssetBaseUrl: Type.TString;
+            entryPath: Type.TString;
+            channels: Type.TArray<Type.TString>;
+            plugins: Type.TArray<Type.TString>;
+          }>>;
+          name: Type.TString;
+          cwd: Type.TString;
+          createdAt: Type.TString;
+          updatedAt: Type.TString;
+          phase: Type.TUnion<[Type.TLiteral<"idle">, Type.TLiteral<"turn">, Type.TLiteral<"compaction">, Type.TLiteral<"retry">]>;
+          phaseSince: Type.TString;
+          attach: Type.TLiteral<"attached">;
+          pendingMessageCount: Type.TNumber;
+          everPrompted: Type.TBoolean;
+          awaitingInput: Type.TBoolean;
+          lastSettledAt: Type.TOptional<Type.TString>;
+          git: Type.TOptional<Type.TObject<{
+            branch: Type.TString;
+            dirty: Type.TBoolean;
+          }>>;
+          profile: Type.TOptional<Type.TObject<{
+            name: Type.TString;
+            displayName: Type.TOptional<Type.TString>;
+            iconVersion: Type.TOptional<Type.TString>;
+          }>>;
+          parentSessionId: Type.TOptional<Type.TString>;
+          sessionProvenance: Type.TOptional<Type.TString>;
+          activity: Type.TOptional<Type.TObject<{
+            label: Type.TString;
+            attention: Type.TOptional<Type.TBoolean>;
+            since: Type.TOptional<Type.TString>;
+          }>>;
+          pendingSetups: Type.TOptional<Type.TArray<Type.TObject<{
+            id: Type.TString;
+            name: Type.TString;
+            createdAt: Type.TString;
+            cwd: Type.TOptional<Type.TString>;
+            setupKind: Type.TOptional<Type.TUnion<[Type.TLiteral<"managed-worktree">, Type.TLiteral<"existing-directory">]>>;
+            status: Type.TOptional<Type.TUnion<[Type.TLiteral<"provisioning">, Type.TLiteral<"failed">, Type.TLiteral<"interrupted">]>>;
+            errorCode: Type.TOptional<Type.TUnion<[Type.TLiteral<"SESSION_WORKTREE_PROVISION_FAILED">, Type.TLiteral<"SESSION_UNAVAILABLE">]>>;
+          }>>>;
+          groups: Type.TOptional<Type.TArray<Type.TString>>;
+          backgroundWorkActive: Type.TOptional<Type.TBoolean>;
+          dormant: Type.TOptional<Type.TBoolean>;
+        }>>;
+        workspaces: Type.TRecord<"^.*$", Type.TObject<{
+          id: Type.TString;
+          root: Type.TString;
+          name: Type.TOptional<Type.TString>;
+          available: Type.TOptional<Type.TBoolean>;
+        }>>;
+        pending: Type.TArray<Type.TObject<{
+          id: Type.TString;
+          sessionId: Type.TString;
+          frame: Type.TRecord<"^.*$", Type.TUnsafe<JsonValue$1>>;
+        }>>;
+      };
+      methods: ChordMethods<{
+        readHome: {
+          args: Type.TObject<{
+            offset: Type.TOptional<Type.TInteger>;
+            limit: Type.TOptional<Type.TInteger>;
+            source: Type.TOptional<Type.TString>;
+            workspaceId: Type.TOptional<Type.TString>;
+          }>;
+          result: Type.TUnsafe<HomeSnapshot>;
+        };
+        invoke: {
+          args: Type.TObject<{
+            mount: Type.TUnion<[Type.TObject<{
+              scope: Type.TLiteral<"global">;
+            }>, Type.TObject<{
+              scope: Type.TLiteral<"workspace">;
+              workspaceId: Type.TString;
+            }>, Type.TObject<{
+              scope: Type.TLiteral<"session">;
+              sessionId: Type.TString;
+            }>]>;
+            service: Type.TString;
+            method: Type.TString;
+            input: Type.TUnknown;
+          }>;
+          result: Type.TUnsafe<JsonValue$1>;
+        };
+        ackNotice: {
+          args: Type.TObject<{
+            id: Type.TString;
+          }>;
+        };
+      }>;
+    };
+  };
+}>;
+export type HubRef = Ref<typeof PoHubContract>;
+//#endregion
+//# sourceMappingURL=protocolHubContract.d.mts.map

package/dist/src/schemas/protocolHubContract.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocolHubContract.d.mts","names":["JsonValue","_$__protocolContracts0.ChordMethods"],"sources":["../../../src/schemas/protocolHubContract.ts"],"mappings":";;;;;;;;qBAaa,iBAAe,KAAA;;;;;YAChB,YAAY,cAAc;YAC1B,iBAAiB,cAAc;YAC/B,mBAAmB,cAAc;qBAOhC,kBAAgB,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAGhB,+CAAa;;;;;IAKtB;MACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MACA,SAWmBC;;UATf,MAAI,KAAA;;;;;;UAMJ,QAAM,KAAA,QAAA;;;UAEE,MAAI,KAAA;;;;;;;;;;;;;;UAAsB,QAAM,KAAA,QAAAD;;;UAC7B,MAAI,KAAA;;;;;;;;YAMb,SAAS,WAAW"}

package/dist/src/schemas/protocolHubContract.mjs

@@ -0,0 +1,49 @@
+import { PO_SERVER_HOST, chordMethods } from "./protocolContracts.mjs";
+import { SessionSummarySchema, WorkspaceSchema } from "./httpApiContracts.mjs";
+import { PoPluginCallSchema } from "./pluginProtocol.mjs";
+import { Type } from "typebox";
+import { hostNamed, remote } from "@earendil-works/chord";
+//#region src/schemas/protocolHubContract.ts
+const Text = Type.String();
+const Json = Type.Unsafe({});
+/** A live session frame every hub client needs (notification entries and agent dialogs) until it is acknowledged. */
+const HubNoticeSchema = Type.Object({
+	id: Text,
+	sessionId: Text,
+	frame: Type.Record(Text, Json)
+});
+const HubState = {
+	sessions: Type.Record(Text, SessionSummarySchema),
+	workspaces: Type.Record(Text, WorkspaceSchema),
+	pending: Type.Array(HubNoticeSchema)
+};
+const PoHubStateSchema = Type.Object(HubState);
+/** What one connection may see: its sessions, its workspaces, and the notices it has not acknowledged. */
+const PoHubContract = remote("po.hub", {
+	version: 1,
+	host: hostNamed(PO_SERVER_HOST),
+	input: Type.Object({}),
+	variants: { default: {
+		state: HubState,
+		methods: chordMethods({
+			readHome: {
+				args: Type.Object({
+					offset: Type.Optional(Type.Integer({ minimum: 0 })),
+					limit: Type.Optional(Type.Integer({ minimum: 1 })),
+					source: Type.Optional(Text),
+					workspaceId: Type.Optional(Text)
+				}),
+				result: Type.Unsafe({})
+			},
+			invoke: {
+				args: PoPluginCallSchema,
+				result: Json
+			},
+			ackNotice: { args: Type.Object({ id: Text }) }
+		})
+	} }
+});
+//#endregion
+export { HubNoticeSchema, PoHubContract, PoHubStateSchema };
+
+//# sourceMappingURL=protocolHubContract.mjs.map

package/dist/src/schemas/protocolHubContract.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocolHubContract.mjs","names":[],"sources":["../../../src/schemas/protocolHubContract.ts"],"sourcesContent":["import { hostNamed, remote, type Ref } from '@earendil-works/chord';\nimport { Type, type Static } from 'typebox';\n\nimport type { HomeSnapshot } from './home';\nimport { SessionSummarySchema, WorkspaceSchema } from './httpApiContracts';\nimport { PoPluginCallSchema } from './pluginProtocol';\nimport { chordMethods, PO_SERVER_HOST } from './protocolContracts';\nimport type { JsonValue } from './sessionProtocol';\n\nconst Text = Type.String();\nconst Json = Type.Unsafe<JsonValue>({});\n\n/** A live session frame every hub client needs (notification entries and agent dialogs) until it is acknowledged. */\nexport const HubNoticeSchema = Type.Object({ id: Text, sessionId: Text, frame: Type.Record(Text, Json) });\nexport type HubNotice = Static<typeof HubNoticeSchema>;\nexport type HubSessionView = Static<typeof SessionSummarySchema>;\nexport type HubWorkspaceView = Static<typeof WorkspaceSchema>;\n\nconst HubState = {\n  sessions: Type.Record(Text, SessionSummarySchema),\n  workspaces: Type.Record(Text, WorkspaceSchema),\n  pending: Type.Array(HubNoticeSchema),\n};\nexport const PoHubStateSchema = Type.Object(HubState);\n\n/** What one connection may see: its sessions, its workspaces, and the notices it has not acknowledged. */\nexport const PoHubContract = remote('po.hub', {\n  version: 1,\n  host: hostNamed(PO_SERVER_HOST),\n  input: Type.Object({}),\n  variants: {\n    default: {\n      state: HubState,\n      methods: chordMethods({\n        readHome: {\n          args: Type.Object({\n            offset: Type.Optional(Type.Integer({ minimum: 0 })),\n            limit: Type.Optional(Type.Integer({ minimum: 1 })),\n            source: Type.Optional(Text),\n            workspaceId: Type.Optional(Text),\n          }),\n          result: Type.Unsafe<HomeSnapshot>({}),\n        },\n        invoke: { args: PoPluginCallSchema, result: Json },\n        ackNotice: { args: Type.Object({ id: Text }) },\n      }),\n    },\n  },\n});\n\nexport type HubRef = Ref<typeof PoHubContract>;\n"],"mappings":";;;;;;AASA,MAAM,OAAO,KAAK,OAAO;AACzB,MAAM,OAAO,KAAK,OAAkB,CAAC,CAAC;;AAGtC,MAAa,kBAAkB,KAAK,OAAO;CAAE,IAAI;CAAM,WAAW;CAAM,OAAO,KAAK,OAAO,MAAM,IAAI;AAAE,CAAC;AAKxG,MAAM,WAAW;CACf,UAAU,KAAK,OAAO,MAAM,oBAAoB;CAChD,YAAY,KAAK,OAAO,MAAM,eAAe;CAC7C,SAAS,KAAK,MAAM,eAAe;AACrC;AACA,MAAa,mBAAmB,KAAK,OAAO,QAAQ;;AAGpD,MAAa,gBAAgB,OAAO,UAAU;CAC5C,SAAS;CACT,MAAM,UAAU,cAAc;CAC9B,OAAO,KAAK,OAAO,CAAC,CAAC;CACrB,UAAU,EACR,SAAS;EACP,OAAO;EACP,SAAS,aAAa;GACpB,UAAU;IACR,MAAM,KAAK,OAAO;KAChB,QAAQ,KAAK,SAAS,KAAK,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;KAClD,OAAO,KAAK,SAAS,KAAK,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;KACjD,QAAQ,KAAK,SAAS,IAAI;KAC1B,aAAa,KAAK,SAAS,IAAI;IACjC,CAAC;IACD,QAAQ,KAAK,OAAqB,CAAC,CAAC;GACtC;GACA,QAAQ;IAAE,MAAM;IAAoB,QAAQ;GAAK;GACjD,WAAW,EAAE,MAAM,KAAK,OAAO,EAAE,IAAI,KAAK,CAAC,EAAE;EAC/C,CAAC;CACH,EACF;AACF,CAAC"}

package/dist/src/schemas/protocolSessionContract.cjs

@@ -0,0 +1,22 @@
+const require_protocolContracts = require("./protocolContracts.cjs");
+const require_sessionApiContracts = require("./sessionApiContracts.cjs");
+let typebox = require("typebox");
+let dist_interop_chord_mjs = require("../../../dist/interop/chord.mjs");
+//#region src/schemas/protocolSessionContract.ts
+/** One live session. `alive` turns false when the runtime behind the object exits. */
+const PoSessionContract = (0, dist_interop_chord_mjs.remote)("po.session", {
+	version: 1,
+	host: (0, dist_interop_chord_mjs.hostNamed)(require_protocolContracts.PO_SERVER_HOST),
+	input: typebox.Type.Object({ sessionId: typebox.Type.String({ minLength: 1 }) }),
+	variants: { default: {
+		state: {
+			state: typebox.Type.Union([typebox.Type.Null(), require_sessionApiContracts.SessionServiceStateSchema]),
+			alive: typebox.Type.Boolean()
+		},
+		methods: require_sessionApiContracts.SessionMethods
+	} }
+});
+//#endregion
+exports.PoSessionContract = PoSessionContract;
+
+//# sourceMappingURL=protocolSessionContract.cjs.map

package/dist/src/schemas/protocolSessionContract.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocolSessionContract.cjs","names":["remote","hostNamed","PO_SERVER_HOST","Type","SessionServiceStateSchema","SessionMethods"],"sources":["../../../src/schemas/protocolSessionContract.ts"],"sourcesContent":["import { hostNamed, remote, type Ref } from '@earendil-works/chord';\nimport { Type } from 'typebox';\n\nimport { PO_SERVER_HOST } from './protocolContracts';\nimport { SessionMethods, SessionServiceStateSchema } from './sessionApiContracts';\n\n/** One live session. `alive` turns false when the runtime behind the object exits. */\nexport const PoSessionContract = remote('po.session', {\n  version: 1,\n  host: hostNamed(PO_SERVER_HOST),\n  input: Type.Object({ sessionId: Type.String({ minLength: 1 }) }),\n  variants: {\n    default: {\n      // null until the runtime behind the object has projected its first state.\n      state: { state: Type.Union([Type.Null(), SessionServiceStateSchema]), alive: Type.Boolean() },\n      methods: SessionMethods,\n    },\n  },\n});\n\nexport type SessionRef = Ref<typeof PoSessionContract>;\n"],"mappings":";;;;;;AAOA,MAAa,qBAAA,GAAoBA,uBAAAA,OAAAA,CAAO,cAAc;CACpD,SAAS;CACT,OAAA,GAAMC,uBAAAA,UAAAA,CAAUC,0BAAAA,cAAc;CAC9B,OAAOC,QAAAA,KAAK,OAAO,EAAE,WAAWA,QAAAA,KAAK,OAAO,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC;CAC/D,UAAU,EACR,SAAS;EAEP,OAAO;GAAE,OAAOA,QAAAA,KAAK,MAAM,CAACA,QAAAA,KAAK,KAAK,GAAGC,4BAAAA,yBAAyB,CAAC;GAAG,OAAOD,QAAAA,KAAK,QAAQ;EAAE;EAC5F,SAASE,4BAAAA;CACX,EACF;AACF,CAAC"}