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

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

@@ -0,0 +1,324 @@
+import { JsonValue as JsonValue$1 } from "./sessionProtocol.mjs";
+import { ChordMethods } from "./protocolContracts.mjs";
+import { Type } from "typebox";
+import { Ref } from "@earendil-works/chord";
+//#region src/schemas/protocolSessionContract.d.ts
+/** One live session. `alive` turns false when the runtime behind the object exits. */
+export declare const PoSessionContract: import("@earendil-works/chord").RemoteContract<{
+  readonly version: 1;
+  readonly host: import("@earendil-works/chord").HostNamed;
+  readonly input: Type.TObject<{
+    sessionId: Type.TString;
+  }>;
+  readonly variants: {
+    default: {
+      state: {
+        state: Type.TUnion<[Type.TNull, Type.TObject<{
+          snapshot: Type.TObject<{
+            fastMode: Type.TBoolean;
+            locked: Type.TBoolean;
+            lifecycle: Type.TOptional<Type.TObject<{
+              revision: Type.TNumber;
+              operation: Type.TUnion<[Type.TNull, Type.TObject<{
+                id: Type.TString;
+                kind: Type.TUnion<[Type.TLiteral<"run">, Type.TLiteral<"compaction">, Type.TLiteral<"navigation">]>;
+                status: Type.TUnion<[Type.TLiteral<"open">, Type.TLiteral<"aborting">]>;
+              }>]>;
+              paused: Type.TBoolean;
+              queue: Type.TArray<Type.TObject<{
+                id: Type.TString;
+                text: Type.TString;
+                images: Type.TOptional<Type.TArray<Type.TObject<{
+                  type: Type.TLiteral<"image">;
+                  data: Type.TString;
+                  mimeType: Type.TString;
+                }>>>;
+                delivery: Type.TUnion<[Type.TLiteral<"steer">, Type.TLiteral<"followUp">, Type.TLiteral<"nextRun">]>;
+                scheduling: Type.TUnion<[Type.TLiteral<"automatic">, Type.TLiteral<"held">]>;
+                disposition: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"handoff">]>;
+              }>>;
+            }>>;
+          }>;
+          presentation: Type.TOptional<Type.TObject<{
+            revision: Type.TNumber;
+            dropped: Type.TNumber;
+            resetRevision: Type.TOptional<Type.TNumber>;
+            events: Type.TArray<Type.TObject<{
+              sequence: Type.TNumber;
+              frame: Type.TIntersect<[Type.TObject<{
+                type: Type.TString;
+              }>, Type.TRecord<"^.*$", Type.TUnsafe<JsonValue$1>>]>;
+            }>>;
+            projections: Type.TArray<Type.TObject<{
+              sequence: Type.TNumber;
+              frame: Type.TIntersect<[Type.TObject<{
+                type: Type.TString;
+              }>, Type.TRecord<"^.*$", Type.TUnsafe<JsonValue$1>>]>;
+            }>>;
+          }>>;
+          live: Type.TOptional<Type.TObject<{
+            phase: Type.TUnion<[Type.TLiteral<"idle">, Type.TLiteral<"turn">, Type.TLiteral<"compaction">, Type.TLiteral<"retry">]>;
+            message: Type.TOptional<Type.TObject<{
+              role: Type.TLiteral<"assistant">;
+              content: Type.TArray<Type.TUnion<[Type.TObject<{
+                type: Type.TLiteral<"text">;
+                text: Type.TString;
+              }>, Type.TObject<{
+                type: Type.TLiteral<"thinking">;
+                thinking: Type.TString;
+                redacted: Type.TOptional<Type.TLiteral<true>>;
+              }>]>>;
+              model: Type.TString;
+              timestamp: Type.TNumber;
+            }>>;
+            tools: Type.TRecord<"^.*$", Type.TObject<{
+              toolCallId: Type.TString;
+              toolName: Type.TString;
+              args: Type.TUnsafe<JsonValue$1>;
+              partialResult: Type.TOptional<Type.TObject<{
+                content: Type.TArray<Type.TUnion<[Type.TObject<{
+                  type: Type.TLiteral<"image">;
+                  data: Type.TString;
+                  mimeType: Type.TString;
+                }>, Type.TObject<{
+                  type: Type.TLiteral<"text">;
+                  text: Type.TString;
+                }>]>>;
+                details: Type.TOptional<Type.TUnsafe<JsonValue$1>>;
+              }>>;
+            }>>;
+          }>>;
+        }>]>;
+        alive: Type.TBoolean;
+      };
+      methods: ChordMethods<{
+        readTranscriptPage: {
+          args: Type.TObject<{
+            cursor: Type.TOptional<Type.TString>;
+            direction: Type.TOptional<Type.TUnion<[Type.TLiteral<"older">, Type.TLiteral<"newer">]>>;
+            limit: Type.TOptional<Type.TNumber>;
+            threadId: Type.TOptional<Type.TString>;
+          }>;
+          result: Type.TObject<{
+            entries: Type.TArray<Type.TUnsafe<JsonValue$1>>;
+            startCursor: Type.TUnion<[Type.TString, Type.TNull]>;
+            endCursor: Type.TUnion<[Type.TString, Type.TNull]>;
+            olderCursor: Type.TUnion<[Type.TString, Type.TNull]>;
+            newerCursor: Type.TUnion<[Type.TString, Type.TNull]>;
+            generation: Type.TNumber;
+            revision: Type.TNumber;
+            context: Type.TArray<Type.TUnsafe<JsonValue$1>>;
+          }>;
+        };
+        prompt: {
+          args: Type.TUnion<[Type.TString, Type.TObject<{
+            text: Type.TString;
+            images: Type.TOptional<Type.TArray<Type.TObject<{
+              type: Type.TLiteral<"image">;
+              data: Type.TString;
+              mimeType: Type.TString;
+            }>>>;
+            waitFor: Type.TOptional<Type.TUnion<[Type.TLiteral<"accepted">, Type.TLiteral<"settled">]>>;
+          }>]>;
+        };
+        steer: {
+          args: Type.TUnion<[Type.TString, Type.TObject<{
+            text: Type.TString;
+            images: Type.TOptional<Type.TArray<Type.TObject<{
+              type: Type.TLiteral<"image">;
+              data: Type.TString;
+              mimeType: Type.TString;
+            }>>>;
+          }>]>;
+        };
+        abort: {};
+        abortOperation: {
+          args: Type.TObject<{
+            operationId: Type.TString;
+          }>;
+        };
+        setModel: {
+          args: Type.TObject<{
+            provider: Type.TString;
+            id: Type.TString;
+          }>;
+        };
+        setThinking: {
+          args: Type.TUnion<[Type.TLiteral<"off">, Type.TLiteral<"minimal">, Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">, Type.TLiteral<"max">, Type.TLiteral<"xhigh">]>;
+        };
+        setFastMode: {
+          args: Type.TBoolean;
+        };
+        setAgentLock: {
+          args: Type.TBoolean;
+        };
+        followUp: {
+          args: Type.TObject<{
+            text: Type.TString;
+            images: Type.TOptional<Type.TArray<Type.TObject<{
+              type: Type.TLiteral<"image">;
+              data: Type.TString;
+              mimeType: Type.TString;
+            }>>>;
+          }>;
+        };
+        enqueueAutomatic: {
+          args: Type.TObject<{
+            text: Type.TString;
+            images: Type.TOptional<Type.TArray<Type.TObject<{
+              type: Type.TLiteral<"image">;
+              data: Type.TString;
+              mimeType: Type.TString;
+            }>>>;
+          }>;
+          result: Type.TObject<{
+            id: Type.TString;
+          }>;
+        };
+        removeQueued: {
+          args: Type.TObject<{
+            id: Type.TString;
+          }>;
+          result: Type.TUnion<[Type.TLiteral<"removed">, Type.TLiteral<"in_flight">, Type.TLiteral<"already_consumed">, Type.TLiteral<"not_found">]>;
+        };
+        promoteQueued: {
+          args: Type.TObject<{
+            id: Type.TString;
+            operationId: Type.TOptional<Type.TString>;
+          }>;
+          result: Type.TUnion<[Type.TLiteral<"promoted">, Type.TLiteral<"in_flight">, Type.TLiteral<"target_changed">, Type.TLiteral<"not_found">]>;
+        };
+        resumeQueue: {};
+        clearQueue: {
+          result: Type.TObject<{
+            steering: Type.TArray<Type.TString>;
+            followUp: Type.TArray<Type.TString>;
+          }>;
+        };
+        rewind: {
+          args: Type.TObject<{
+            itemId: Type.TString;
+            summarize: Type.TOptional<Type.TBoolean>;
+            customInstructions: Type.TOptional<Type.TString>;
+            replaceInstructions: Type.TOptional<Type.TBoolean>;
+            label: Type.TOptional<Type.TString>;
+          }>;
+          result: Type.TObject<{
+            editorText: Type.TOptional<Type.TString>;
+            cancelled: Type.TBoolean;
+            aborted: Type.TOptional<Type.TBoolean>;
+            summaryEntry: Type.TOptional<Type.TObject<{
+              id: Type.TString;
+              parentId: Type.TUnion<[Type.TString, Type.TNull]>;
+              timestamp: Type.TString;
+              fromId: Type.TString;
+              summary: Type.TString;
+              details: Type.TOptional<Type.TUnsafe<JsonValue$1>>;
+              usage: Type.TOptional<Type.TObject<{
+                input: Type.TNumber;
+                output: Type.TNumber;
+                cacheRead: Type.TNumber;
+                cacheWrite: Type.TNumber;
+                total: Type.TNumber;
+              }>>;
+              fromHook: Type.TOptional<Type.TBoolean>;
+            }>>;
+          }>;
+        };
+        extensionUiResponse: {
+          args: Type.TUnion<[Type.TObject<{
+            id: Type.TString;
+            value: Type.TString;
+          }>, Type.TObject<{
+            id: Type.TString;
+            confirmed: Type.TBoolean;
+          }>, Type.TObject<{
+            id: Type.TString;
+            cancelled: Type.TLiteral<true>;
+          }>]>;
+        };
+        getState: {
+          result: Type.TObject<{
+            model: Type.TOptional<Type.TObject<{
+              provider: Type.TString;
+              id: Type.TString;
+            }>>;
+            thinkingLevel: Type.TUnion<[Type.TLiteral<"off">, Type.TLiteral<"minimal">, Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">, Type.TLiteral<"max">, Type.TLiteral<"xhigh">]>;
+            fastMode: Type.TBoolean;
+            agentLocked: Type.TOptional<Type.TBoolean>;
+            isStreaming: Type.TBoolean;
+            isCompacting: Type.TBoolean;
+            steeringMode: Type.TUnion<[Type.TLiteral<"all">, Type.TLiteral<"one-at-a-time">]>;
+            followUpMode: Type.TUnion<[Type.TLiteral<"all">, Type.TLiteral<"one-at-a-time">]>;
+            sessionId: Type.TString;
+            sessionName: Type.TOptional<Type.TString>;
+            autoCompactionEnabled: Type.TBoolean;
+            messageCount: Type.TNumber;
+            pendingMessageCount: Type.TNumber;
+            operationId: Type.TOptional<Type.TString>;
+            executionStatus: Type.TOptional<Type.TUnion<[Type.TLiteral<"open">, Type.TLiteral<"aborting">]>>;
+            queuePaused: Type.TOptional<Type.TBoolean>;
+            queueRevision: Type.TOptional<Type.TNumber>;
+          }>;
+        };
+        getSessionStats: {
+          result: Type.TObject<{
+            sessionId: Type.TString;
+            totalMessages: Type.TNumber;
+            tokens: Type.TObject<{
+              input: Type.TNumber;
+              output: Type.TNumber;
+              cacheRead: Type.TNumber;
+              cacheWrite: Type.TNumber;
+              total: Type.TNumber;
+            }>;
+            cost: Type.TNumber;
+            contextUsage: Type.TOptional<Type.TObject<{
+              tokens: Type.TUnion<[Type.TNumber, Type.TNull]>;
+              contextWindow: Type.TNumber;
+              percent: Type.TUnion<[Type.TNumber, Type.TNull]>;
+            }>>;
+          }>;
+        };
+        getCommands: {
+          result: Type.TArray<Type.TObject<{
+            name: Type.TString;
+            description: Type.TOptional<Type.TString>;
+            source: Type.TUnion<[Type.TLiteral<"extension">, Type.TLiteral<"prompt">, Type.TLiteral<"skill">]>;
+            sourceInfo: Type.TOptional<Type.TObject<{
+              path: Type.TString;
+              source: Type.TString;
+              scope: Type.TUnion<[Type.TLiteral<"user">, Type.TLiteral<"project">, Type.TLiteral<"temporary">]>;
+              origin: Type.TUnion<[Type.TLiteral<"package">, Type.TLiteral<"top-level">]>;
+              baseDir: Type.TOptional<Type.TString>;
+            }>>;
+          }>>;
+        };
+        getAvailableModels: {
+          result: Type.TArray<Type.TObject<{
+            provider: Type.TString;
+            id: Type.TString;
+          }>>;
+        };
+        getAvailableThinkingLevels: {
+          result: Type.TArray<Type.TUnion<[Type.TLiteral<"off">, Type.TLiteral<"minimal">, Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">, Type.TLiteral<"max">, Type.TLiteral<"xhigh">]>>;
+        };
+        compact: {
+          args: Type.TObject<{
+            customInstructions: Type.TOptional<Type.TString>;
+          }>;
+          result: Type.TUnsafe<JsonValue$1>;
+        };
+        setName: {
+          args: Type.TString;
+        };
+        setGroups: {
+          args: Type.TArray<Type.TString>;
+        };
+      }>;
+    };
+  };
+}>;
+export type SessionRef = Ref<typeof PoSessionContract>;
+//#endregion
+//# sourceMappingURL=protocolSessionContract.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"protocolSessionContract.d.mts","names":["_$__sessionProtocol0.JsonValue","_$__protocolContracts0.ChordMethods"],"sources":["../../../src/schemas/protocolSessionContract.ts"],"mappings":";;;;;;qBAOa,mDAAiB;;;;;;;IAK1B;MAEE;QAAS,OAAK,KAAA,QAAA,KAAA,OAAA,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAAwD,OAAK,KAAA;;MAC3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAKM,aAAa,WAAW"}

package/dist/src/schemas/protocolSessionContract.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"protocolSessionContract.mjs","names":[],"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,oBAAoB,OAAO,cAAc;CACpD,SAAS;CACT,MAAM,UAAU,cAAc;CAC9B,OAAO,KAAK,OAAO,EAAE,WAAW,KAAK,OAAO,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC;CAC/D,UAAU,EACR,SAAS;EAEP,OAAO;GAAE,OAAO,KAAK,MAAM,CAAC,KAAK,KAAK,GAAG,yBAAyB,CAAC;GAAG,OAAO,KAAK,QAAQ;EAAE;EAC5F,SAAS;CACX,EACF;AACF,CAAC"}

package/dist/src/schemas/protocolThreadContract.cjs

@@ -0,0 +1,21 @@
+const require_protocolContracts = require("./protocolContracts.cjs");
+let typebox = require("typebox");
+let dist_interop_chord_mjs = require("../../../dist/interop/chord.mjs");
+//#region src/schemas/protocolThreadContract.ts
+/** The thread's latest frame: `transcript_state` while its child runs, `transcript_ready` once it has finished. */
+const PoThreadFrameSchema = typebox.Type.Union([typebox.Type.Null(), typebox.Type.Intersect([typebox.Type.Object({ type: typebox.Type.String() }), typebox.Type.Record(typebox.Type.String(), typebox.Type.Unsafe({}))])]);
+/** One child thread of a session, followed only while someone holds it. */
+const PoThreadContract = (0, dist_interop_chord_mjs.remote)("po.thread", {
+	version: 1,
+	host: (0, dist_interop_chord_mjs.hostNamed)(require_protocolContracts.PO_SERVER_HOST),
+	input: typebox.Type.Object({
+		sessionId: typebox.Type.String({ minLength: 1 }),
+		threadId: typebox.Type.String({ minLength: 1 })
+	}),
+	variants: { default: { state: { frame: PoThreadFrameSchema } } }
+});
+//#endregion
+exports.PoThreadContract = PoThreadContract;
+exports.PoThreadFrameSchema = PoThreadFrameSchema;
+
+//# sourceMappingURL=protocolThreadContract.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"protocolThreadContract.cjs","names":["Type","remote","hostNamed","PO_SERVER_HOST"],"sources":["../../../src/schemas/protocolThreadContract.ts"],"sourcesContent":["import { hostNamed, remote, type Ref } from '@earendil-works/chord';\nimport { Type } from 'typebox';\n\nimport { PO_SERVER_HOST } from './protocolContracts';\nimport type { JsonValue } from './sessionProtocol';\n\n/** The thread's latest frame: `transcript_state` while its child runs, `transcript_ready` once it has finished. */\nexport const PoThreadFrameSchema = Type.Union([\n  Type.Null(),\n  Type.Intersect([Type.Object({ type: Type.String() }), Type.Record(Type.String(), Type.Unsafe<JsonValue>({}))]),\n]);\n\n/** One child thread of a session, followed only while someone holds it. */\nexport const PoThreadContract = remote('po.thread', {\n  version: 1,\n  host: hostNamed(PO_SERVER_HOST),\n  input: Type.Object({ sessionId: Type.String({ minLength: 1 }), threadId: Type.String({ minLength: 1 }) }),\n  variants: {\n    default: { state: { frame: PoThreadFrameSchema } },\n  },\n});\n\nexport type ThreadRef = Ref<typeof PoThreadContract>;\n"],"mappings":";;;;;AAOA,MAAa,sBAAsBA,QAAAA,KAAK,MAAM,CAC5CA,QAAAA,KAAK,KAAK,GACVA,QAAAA,KAAK,UAAU,CAACA,QAAAA,KAAK,OAAO,EAAE,MAAMA,QAAAA,KAAK,OAAO,EAAE,CAAC,GAAGA,QAAAA,KAAK,OAAOA,QAAAA,KAAK,OAAO,GAAGA,QAAAA,KAAK,OAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAC/G,CAAC;;AAGD,MAAa,oBAAA,GAAmBC,uBAAAA,OAAAA,CAAO,aAAa;CAClD,SAAS;CACT,OAAA,GAAMC,uBAAAA,UAAAA,CAAUC,0BAAAA,cAAc;CAC9B,OAAOH,QAAAA,KAAK,OAAO;EAAE,WAAWA,QAAAA,KAAK,OAAO,EAAE,WAAW,EAAE,CAAC;EAAG,UAAUA,QAAAA,KAAK,OAAO,EAAE,WAAW,EAAE,CAAC;CAAE,CAAC;CACxG,UAAU,EACR,SAAS,EAAE,OAAO,EAAE,OAAO,oBAAoB,EAAE,EACnD;AACF,CAAC"}

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

@@ -0,0 +1,29 @@
+import { JsonValue as JsonValue$1 } from "./sessionProtocol.mjs";
+import { Type } from "typebox";
+import { Ref } from "@earendil-works/chord";
+//#region src/schemas/protocolThreadContract.d.ts
+/** The thread's latest frame: `transcript_state` while its child runs, `transcript_ready` once it has finished. */
+export declare const PoThreadFrameSchema: Type.TUnion<[Type.TNull, Type.TIntersect<[Type.TObject<{
+  type: Type.TString;
+}>, Type.TRecord<"^.*$", Type.TUnsafe<JsonValue$1>>]>]>;
+/** One child thread of a session, followed only while someone holds it. */
+export declare const PoThreadContract: import("@earendil-works/chord").RemoteContract<{
+  readonly version: 1;
+  readonly host: import("@earendil-works/chord").HostNamed;
+  readonly input: Type.TObject<{
+    sessionId: Type.TString;
+    threadId: Type.TString;
+  }>;
+  readonly variants: {
+    default: {
+      state: {
+        frame: Type.TUnion<[Type.TNull, Type.TIntersect<[Type.TObject<{
+          type: Type.TString;
+        }>, Type.TRecord<"^.*$", Type.TUnsafe<JsonValue$1>>]>]>;
+      };
+    };
+  };
+}>;
+export type ThreadRef = Ref<typeof PoThreadContract>;
+//#endregion
+//# sourceMappingURL=protocolThreadContract.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"protocolThreadContract.d.mts","names":["JsonValue"],"sources":["../../../src/schemas/protocolThreadContract.ts"],"mappings":";;;;;qBAOa,qBAAmB,KAAA,QAAA,KAAA,OAAA,KAAA,YAAA,KAAA;;IAG9B,KAAA,gBAAA,KAAA,QAAAA;;qBAGW,kDAAgB;;;;;;;;IAKzB;MAAW;QAAS,OAAK,KAAA,QAAA,KAAA,OAAA,KAAA,YAAA,KAAA;;;;;;;YAIjB,YAAY,WAAW"}

package/dist/src/schemas/protocolThreadContract.mjs

@@ -0,0 +1,20 @@
+import { PO_SERVER_HOST } from "./protocolContracts.mjs";
+import { Type } from "typebox";
+import { hostNamed, remote } from "@earendil-works/chord";
+//#region src/schemas/protocolThreadContract.ts
+/** The thread's latest frame: `transcript_state` while its child runs, `transcript_ready` once it has finished. */
+const PoThreadFrameSchema = Type.Union([Type.Null(), Type.Intersect([Type.Object({ type: Type.String() }), Type.Record(Type.String(), Type.Unsafe({}))])]);
+/** One child thread of a session, followed only while someone holds it. */
+const PoThreadContract = remote("po.thread", {
+	version: 1,
+	host: hostNamed(PO_SERVER_HOST),
+	input: Type.Object({
+		sessionId: Type.String({ minLength: 1 }),
+		threadId: Type.String({ minLength: 1 })
+	}),
+	variants: { default: { state: { frame: PoThreadFrameSchema } } }
+});
+//#endregion
+export { PoThreadContract, PoThreadFrameSchema };
+
+//# sourceMappingURL=protocolThreadContract.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"protocolThreadContract.mjs","names":[],"sources":["../../../src/schemas/protocolThreadContract.ts"],"sourcesContent":["import { hostNamed, remote, type Ref } from '@earendil-works/chord';\nimport { Type } from 'typebox';\n\nimport { PO_SERVER_HOST } from './protocolContracts';\nimport type { JsonValue } from './sessionProtocol';\n\n/** The thread's latest frame: `transcript_state` while its child runs, `transcript_ready` once it has finished. */\nexport const PoThreadFrameSchema = Type.Union([\n  Type.Null(),\n  Type.Intersect([Type.Object({ type: Type.String() }), Type.Record(Type.String(), Type.Unsafe<JsonValue>({}))]),\n]);\n\n/** One child thread of a session, followed only while someone holds it. */\nexport const PoThreadContract = remote('po.thread', {\n  version: 1,\n  host: hostNamed(PO_SERVER_HOST),\n  input: Type.Object({ sessionId: Type.String({ minLength: 1 }), threadId: Type.String({ minLength: 1 }) }),\n  variants: {\n    default: { state: { frame: PoThreadFrameSchema } },\n  },\n});\n\nexport type ThreadRef = Ref<typeof PoThreadContract>;\n"],"mappings":";;;;;AAOA,MAAa,sBAAsB,KAAK,MAAM,CAC5C,KAAK,KAAK,GACV,KAAK,UAAU,CAAC,KAAK,OAAO,EAAE,MAAM,KAAK,OAAO,EAAE,CAAC,GAAG,KAAK,OAAO,KAAK,OAAO,GAAG,KAAK,OAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAC/G,CAAC;;AAGD,MAAa,mBAAmB,OAAO,aAAa;CAClD,SAAS;CACT,MAAM,UAAU,cAAc;CAC9B,OAAO,KAAK,OAAO;EAAE,WAAW,KAAK,OAAO,EAAE,WAAW,EAAE,CAAC;EAAG,UAAU,KAAK,OAAO,EAAE,WAAW,EAAE,CAAC;CAAE,CAAC;CACxG,UAAU,EACR,SAAS,EAAE,OAAO,EAAE,OAAO,oBAAoB,EAAE,EACnD;AACF,CAAC"}

package/dist/src/schemas/readiness.cjs

@@ -1,24 +1,24 @@
 //#region src/schemas/readiness.ts
 /** Cordis service name for session-scoped package initialization. */
-const DOOM_READINESS_SERVICE = "doom/readiness";
+const PO_READINESS_SERVICE = "po/readiness";
 /** Stable machine-readable failures produced by the readiness contract. */
-const DOOM_READINESS_ERROR_CODE = {
-	cancelled: "DOOM_READINESS_CANCELLED",
-	disposed: "DOOM_READINESS_DISPOSED",
-	duplicate: "DOOM_READINESS_DUPLICATE",
-	failed: "DOOM_READINESS_FAILED",
-	invalidArgument: "DOOM_READINESS_INVALID_ARGUMENT",
-	unavailable: "DOOM_READINESS_UNAVAILABLE",
-	waitAborted: "DOOM_READINESS_WAIT_ABORTED"
+const PO_READINESS_ERROR_CODE = {
+	cancelled: "PO_READINESS_CANCELLED",
+	disposed: "PO_READINESS_DISPOSED",
+	duplicate: "PO_READINESS_DUPLICATE",
+	failed: "PO_READINESS_FAILED",
+	invalidArgument: "PO_READINESS_INVALID_ARGUMENT",
+	unavailable: "PO_READINESS_UNAVAILABLE",
+	waitAborted: "PO_READINESS_WAIT_ABORTED"
 };
 /** Error returned to package callers without exposing task-specific rejection shapes. */
-var DoomReadinessError = class extends Error {
+var PoReadinessError = class extends Error {
 	code;
 	packageId;
 	generation;
 	constructor(code, message, input = {}) {
 		super(message, input.cause === void 0 ? void 0 : { cause: input.cause });
-		this.name = "DoomReadinessError";
+		this.name = "PoReadinessError";
 		this.code = code;
 		this.packageId = input.packageId;
 		this.generation = input.generation;
@@ -35,7 +35,7 @@ function createTerminal() {
 }
 function frozenDiagnostics(diagnostics) {
 	if (diagnostics === void 0) return Object.freeze([]);
-	if (!Array.isArray(diagnostics) || diagnostics.some((diagnostic) => typeof diagnostic !== "string")) throw new TypeError("Doom readiness task diagnostics must be an array of strings.");
+	if (!Array.isArray(diagnostics) || diagnostics.some((diagnostic) => typeof diagnostic !== "string")) throw new TypeError("Po readiness task diagnostics must be an array of strings.");
 	return Object.freeze([...diagnostics]);
 }
 function errorDetail(error) {
@@ -59,7 +59,7 @@ function rethrowAsync(error) {
 	});
 }
 function waitAbortedError(record, signal) {
-	return new DoomReadinessError(DOOM_READINESS_ERROR_CODE.waitAborted, `Waiting for Doom package '${record.packageId}' readiness was aborted.`, {
+	return new PoReadinessError(PO_READINESS_ERROR_CODE.waitAborted, `Waiting for Po package '${record.packageId}' readiness was aborted.`, {
 		packageId: record.packageId,
 		generation: record.generation,
 		cause: signal.reason
@@ -80,7 +80,7 @@ function waitForTerminal(record, signal) {
 	});
 }
 /** Creates the session-scoped coordinator value published through Cordis. */
-function createDoomReadinessCoordinator(options = {}) {
+function createPoReadinessCoordinator(options = {}) {
 	const records = /* @__PURE__ */ new Map();
 	let disposed = false;
 	let disposal;
@@ -114,14 +114,14 @@ function createDoomReadinessCoordinator(options = {}) {
 		wait: async (waitOptions = {}) => {
 			await waitForTerminal(record, waitOptions.signal);
 			if (record.state === "ready" || record.state === "degraded") {
-				if (!record.hasValue) throw new DoomReadinessError(DOOM_READINESS_ERROR_CODE.failed, `Doom package '${record.packageId}' readiness completed without a value.`, {
+				if (!record.hasValue) throw new PoReadinessError(PO_READINESS_ERROR_CODE.failed, `Po package '${record.packageId}' readiness completed without a value.`, {
 					packageId: record.packageId,
 					generation: record.generation
 				});
 				return record.value;
 			}
 			if (record.error) throw record.error;
-			throw new DoomReadinessError(DOOM_READINESS_ERROR_CODE.failed, `Doom package '${record.packageId}' readiness did not complete.`, {
+			throw new PoReadinessError(PO_READINESS_ERROR_CODE.failed, `Po package '${record.packageId}' readiness did not complete.`, {
 				packageId: record.packageId,
 				generation: record.generation
 			});
@@ -129,23 +129,23 @@ function createDoomReadinessCoordinator(options = {}) {
 	});
 	return Object.freeze({
 		start(packageId, generation, task) {
-			if (disposed) throw new DoomReadinessError(DOOM_READINESS_ERROR_CODE.disposed, "The Doom readiness coordinator has been disposed.", {
+			if (disposed) throw new PoReadinessError(PO_READINESS_ERROR_CODE.disposed, "The Po readiness coordinator has been disposed.", {
 				packageId,
 				generation
 			});
-			if (typeof packageId !== "string" || packageId.trim().length === 0) throw new DoomReadinessError(DOOM_READINESS_ERROR_CODE.invalidArgument, "Doom readiness requires a non-empty package id.", {
+			if (typeof packageId !== "string" || packageId.trim().length === 0) throw new PoReadinessError(PO_READINESS_ERROR_CODE.invalidArgument, "Po readiness requires a non-empty package id.", {
 				packageId,
 				generation
 			});
-			if (typeof generation !== "string" || generation.trim().length === 0) throw new DoomReadinessError(DOOM_READINESS_ERROR_CODE.invalidArgument, "Doom readiness requires a non-empty generation.", {
+			if (typeof generation !== "string" || generation.trim().length === 0) throw new PoReadinessError(PO_READINESS_ERROR_CODE.invalidArgument, "Po readiness requires a non-empty generation.", {
 				packageId,
 				generation
 			});
-			if (typeof task !== "function") throw new DoomReadinessError(DOOM_READINESS_ERROR_CODE.invalidArgument, "Doom readiness requires an initialization task.", {
+			if (typeof task !== "function") throw new PoReadinessError(PO_READINESS_ERROR_CODE.invalidArgument, "Po readiness requires an initialization task.", {
 				packageId,
 				generation
 			});
-			if (records.get(packageId)?.state === "pending") throw new DoomReadinessError(DOOM_READINESS_ERROR_CODE.duplicate, `Doom package '${packageId}' already has live readiness work.`, {
+			if (records.get(packageId)?.state === "pending") throw new PoReadinessError(PO_READINESS_ERROR_CODE.duplicate, `Po package '${packageId}' already has live readiness work.`, {
 				packageId,
 				generation
 			});
@@ -173,7 +173,7 @@ function createDoomReadinessCoordinator(options = {}) {
 			operation.then((result) => {
 				if (!current(record)) return;
 				if (result === null || typeof result !== "object" || !Object.hasOwn(result, "value")) {
-					finish(record, "failed", { error: new DoomReadinessError(DOOM_READINESS_ERROR_CODE.failed, `Doom package '${packageId}' returned an invalid readiness result.`, {
+					finish(record, "failed", { error: new PoReadinessError(PO_READINESS_ERROR_CODE.failed, `Po package '${packageId}' returned an invalid readiness result.`, {
 						packageId,
 						generation
 					}) });
@@ -187,14 +187,14 @@ function createDoomReadinessCoordinator(options = {}) {
 						diagnostics
 					});
 				} catch (error) {
-					finish(record, "failed", { error: new DoomReadinessError(DOOM_READINESS_ERROR_CODE.failed, `Doom package '${packageId}' returned an invalid readiness result.`, {
+					finish(record, "failed", { error: new PoReadinessError(PO_READINESS_ERROR_CODE.failed, `Po package '${packageId}' returned an invalid readiness result.`, {
 						packageId,
 						generation,
 						cause: error
 					}) });
 				}
 			}, (error) => {
-				finish(record, "failed", { error: new DoomReadinessError(DOOM_READINESS_ERROR_CODE.failed, `Doom package '${packageId}' readiness failed: ${error instanceof Error ? error.message : String(error)}`, {
+				finish(record, "failed", { error: new PoReadinessError(PO_READINESS_ERROR_CODE.failed, `Po package '${packageId}' readiness failed: ${error instanceof Error ? error.message : String(error)}`, {
 					packageId,
 					generation,
 					cause: error
@@ -214,7 +214,7 @@ function createDoomReadinessCoordinator(options = {}) {
 			disposed = true;
 			const operations = [...records.values()].map((record) => {
 				if (record.state === "pending") {
-					const error = new DoomReadinessError(DOOM_READINESS_ERROR_CODE.cancelled, `Doom package '${record.packageId}' readiness was cancelled.`, {
+					const error = new PoReadinessError(PO_READINESS_ERROR_CODE.cancelled, `Po package '${record.packageId}' readiness was cancelled.`, {
 						packageId: record.packageId,
 						generation: record.generation
 					});
@@ -231,21 +231,21 @@ function createDoomReadinessCoordinator(options = {}) {
 	});
 }
 /** Reads the coordinator visible to the current Cordis plugin context. */
-function readDoomReadinessCoordinator(ctx) {
-	return ctx.get(DOOM_READINESS_SERVICE);
+function readPoReadinessCoordinator(ctx) {
+	return ctx.get(PO_READINESS_SERVICE);
 }
 /** Reads the coordinator or reports that Config has not published session readiness. */
-function requireDoomReadinessCoordinator(ctx) {
-	const coordinator = readDoomReadinessCoordinator(ctx);
+function requirePoReadinessCoordinator(ctx) {
+	const coordinator = readPoReadinessCoordinator(ctx);
 	if (coordinator) return coordinator;
-	throw new DoomReadinessError(DOOM_READINESS_ERROR_CODE.unavailable, "Doom readiness is unavailable. Load the Po Config core.");
+	throw new PoReadinessError(PO_READINESS_ERROR_CODE.unavailable, "Po readiness is unavailable. Load the Po Config core.");
 }
 //#endregion
-exports.DOOM_READINESS_ERROR_CODE = DOOM_READINESS_ERROR_CODE;
-exports.DOOM_READINESS_SERVICE = DOOM_READINESS_SERVICE;
-exports.DoomReadinessError = DoomReadinessError;
-exports.createDoomReadinessCoordinator = createDoomReadinessCoordinator;
-exports.readDoomReadinessCoordinator = readDoomReadinessCoordinator;
-exports.requireDoomReadinessCoordinator = requireDoomReadinessCoordinator;
+exports.PO_READINESS_ERROR_CODE = PO_READINESS_ERROR_CODE;
+exports.PO_READINESS_SERVICE = PO_READINESS_SERVICE;
+exports.PoReadinessError = PoReadinessError;
+exports.createPoReadinessCoordinator = createPoReadinessCoordinator;
+exports.readPoReadinessCoordinator = readPoReadinessCoordinator;
+exports.requirePoReadinessCoordinator = requirePoReadinessCoordinator;
 
 //# sourceMappingURL=readiness.cjs.map