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

package/dist/agentModel.cjs

@@ -1,4 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_agentModel = require("./src/schemas/agentModel.cjs");
 exports.AgentModelProjectionSchema = require_agentModel.AgentModelProjectionSchema;
-exports.DOOM_AGENT_MODEL_ENTRY_TYPE = require_agentModel.DOOM_AGENT_MODEL_ENTRY_TYPE;
+exports.PO_AGENT_MODEL_ENTRY_TYPE = require_agentModel.PO_AGENT_MODEL_ENTRY_TYPE;

package/dist/agentModel.d.mts

@@ -1,2 +1,2 @@
-import { AgentModelProjection, AgentModelProjectionSchema, DOOM_AGENT_MODEL_ENTRY_TYPE } from "./src/schemas/agentModel.mjs";
-export { type AgentModelProjection, AgentModelProjectionSchema, DOOM_AGENT_MODEL_ENTRY_TYPE };
+import { AgentModelProjection, AgentModelProjectionSchema, PO_AGENT_MODEL_ENTRY_TYPE } from "./src/schemas/agentModel.mjs";
+export { type AgentModelProjection, AgentModelProjectionSchema, PO_AGENT_MODEL_ENTRY_TYPE };

package/dist/agentModel.mjs

@@ -1,2 +1 @@
-import { AgentModelProjectionSchema, DOOM_AGENT_MODEL_ENTRY_TYPE } from "./src/schemas/agentModel.mjs";
-export { AgentModelProjectionSchema, DOOM_AGENT_MODEL_ENTRY_TYPE };
+export { AgentModelProjectionSchema, PO_AGENT_MODEL_ENTRY_TYPE } from "./src/schemas/agentModel.mjs";

package/dist/apiContracts.cjs

@@ -1,11 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let typebox = require("typebox");
 let typebox_value = require("typebox/value");
-let _earendil_works_pi_protocol = require("@earendil-works/pi-protocol");
-let _earendil_works_chord = require("@earendil-works/chord");
 //#region src/schemas/apiContracts.ts
-const DOOM_API_CONTRACT_VERSION = 1;
-const DOOM_API_CONTRACT_FILE = "contracts.json";
+const PO_API_CONTRACT_VERSION = 1;
+const PO_API_CONTRACT_FILE = "contracts.json";
 const Schema = typebox.Type.Unsafe(typebox.Type.Union([typebox.Type.Boolean(), typebox.Type.Record(typebox.Type.String(), typebox.Type.Unknown())]));
 const Scope = typebox.Type.Union([
 	typebox.Type.Literal("global"),
@@ -20,7 +18,7 @@ const ResponseSchema = typebox.Type.Object({
 	events: typebox.Type.Optional(typebox.Type.Record(Named, Schema))
 });
 /** Data-only package entry. Schemas use JSON Schema draft-07, including TypeBox output; OpenAPI export translates tuple keywords. */
-const DoomApiContractSchema = typebox.Type.Object({
+const PoApiContractSchema = typebox.Type.Object({
 	version: typebox.Type.Literal(1),
 	protocols: typebox.Type.Optional(typebox.Type.Record(Named, Named)),
 	schemas: typebox.Type.Optional(typebox.Type.Record(Named, Schema)),
@@ -89,7 +87,7 @@ function defineApiContract(contract) {
 	return contract;
 }
 function parseApiContract(value) {
-	if (!(0, typebox_value.Check)(DoomApiContractSchema, value)) throw new Error("Invalid Po API contract");
+	if (!(0, typebox_value.Check)(PoApiContractSchema, value)) throw new Error("Invalid Po API contract");
 	const contract = value;
 	const ids = /* @__PURE__ */ new Set();
 	for (const entry of [...contract.http, ...contract.sockets]) {
@@ -117,7 +115,7 @@ function parseCompiledContracts(value) {
 			majorMode: Named,
 			layer: Named
 		}), { minItems: 1 }),
-		contract: typebox.Type.Optional(DoomApiContractSchema),
+		contract: typebox.Type.Optional(PoApiContractSchema),
 		problem: typebox.Type.Optional(Named),
 		module: typebox.Type.Optional(typebox.Type.String({ pattern: "^\\./[^\\\\%?#]+$" }))
 	});
@@ -1244,13 +1242,6 @@ const bundleHttpContracts = [...["/bundle-manifest.json", "/api/web-plugins/{id}
 	}
 })))];
 //#endregion
-//#region src/schemas/sessionProtocol.ts
-const DOOM_SESSION_SERVICE_ID = "po.session.v2";
-const DOOM_SESSION_MANAGEMENT_SERVICE_ID = "po.session-management.v1";
-(0, _earendil_works_chord.defineService)("po.hub.v1");
-(0, _earendil_works_chord.defineService)(DOOM_SESSION_SERVICE_ID);
-(0, _earendil_works_chord.defineService)(DOOM_SESSION_MANAGEMENT_SERVICE_ID);
-//#endregion
 //#region src/schemas/sessionApiContracts.ts
 const Text = typebox.Type.String();
 const NumberValue = typebox.Type.Number();
@@ -1709,7 +1700,8 @@ const SessionMethodSchemas = {
 		input: typebox.Type.Tuple([typebox.Type.Object({ customInstructions: Optional(Text) })]),
 		output: Json$1
 	},
-	setName: { input: typebox.Type.Tuple([Text]) }
+	setName: { input: typebox.Type.Tuple([Text]) },
+	setGroups: { input: typebox.Type.Tuple([typebox.Type.Array(Text)]) }
 };
 const ErrorSchema = typebox.Type.Object({
 	code: Text,
@@ -1719,50 +1711,28 @@ const sessionSocketContracts = [
 	...Object.entries(SessionMethodSchemas).map(([member, definition]) => ({
 		id: `session.${member}`,
 		scope: "session",
-		service: DOOM_SESSION_SERVICE_ID,
+		service: "po.session",
 		member,
 		direction: "client-to-server",
 		kind: "method",
-		description: `Session ${member}. Arguments exclude the process-local Chord Context. A void result is omitted from the successful Pi response.`,
+		description: `Session ${member}. The Chord call carries the first argument (null when there is none); a void result is null.`,
 		...definition,
 		errors: ErrorSchema
 	})),
 	{
 		id: "session.state",
 		scope: "session",
-		service: DOOM_SESSION_SERVICE_ID,
+		service: "po.session",
 		member: "state",
 		direction: "server-to-client",
 		kind: "state",
 		input: SessionServiceStateSchema,
-		description: "Reconstructed session state after Chord snapshot/delta decoding."
-	},
-	{
-		id: "management.attach",
-		scope: "global",
-		service: DOOM_SESSION_MANAGEMENT_SERVICE_ID,
-		member: "attach",
-		direction: "client-to-server",
-		kind: "method",
-		input: typebox.Type.Tuple([Text]),
-		errors: ErrorSchema,
-		description: "Attach this presentation to a session. Pi publishes an out-of-band attachment update."
-	},
-	{
-		id: "management.detach",
-		scope: "global",
-		service: DOOM_SESSION_MANAGEMENT_SERVICE_ID,
-		member: "detach",
-		direction: "client-to-server",
-		kind: "method",
-		input: typebox.Type.Tuple([]),
-		errors: ErrorSchema,
-		description: "Detach this presentation from its selected session."
+		description: "The `state` member of `po.session`, reconstructed from Chord snapshot and delta frames."
 	},
 	{
 		id: "hub.send",
 		scope: "global",
-		service: "po.hub.v1",
+		service: "po.hub",
 		member: "send",
 		direction: "client-to-server",
 		kind: "method",
@@ -1773,7 +1743,7 @@ const sessionSocketContracts = [
 	{
 		id: "hub.state",
 		scope: "global",
-		service: "po.hub.v1",
+		service: "po.hub",
 		member: "state",
 		direction: "server-to-client",
 		kind: "state",
@@ -1787,7 +1757,7 @@ const sessionSocketContracts = [
 //#endregion
 //#region src/schemas/pluginProtocol.ts
 /** The address is always exact. A workspace call never resolves to a global service. */
-const DoomPluginMountSchema = typebox.Type.Union([
+const PoPluginMountSchema = typebox.Type.Union([
 	typebox.Type.Object({ scope: typebox.Type.Literal("global") }, { additionalProperties: false }),
 	typebox.Type.Object({
 		scope: typebox.Type.Literal("workspace"),
@@ -1798,39 +1768,38 @@ const DoomPluginMountSchema = typebox.Type.Union([
 		sessionId: typebox.Type.String({ minLength: 1 })
 	}, { additionalProperties: false })
 ]);
-const DoomPluginCallSchema = typebox.Type.Object({
-	mount: DoomPluginMountSchema,
+const PoPluginCallSchema = typebox.Type.Object({
+	mount: PoPluginMountSchema,
 	service: typebox.Type.String({ minLength: 1 }),
 	method: typebox.Type.String({ minLength: 1 }),
 	input: typebox.Type.Unknown()
 }, { additionalProperties: false });
-(0, _earendil_works_chord.defineService)("po.plugin.v1");
 //#endregion
 //#region src/schemas/transportApiContracts.ts
+/** The Chord release whose link frames this file describes. */
+const CHORD_WIRE_VERSION = "1.2.0";
 const S = typebox.Type.String({ minLength: 1 });
-const Json = typebox.Type.Unknown({ description: "JSON value; its application shape is defined by the addressed service member." });
-const E = typebox.Type.Object({
-	code: S,
-	message: typebox.Type.String()
-}, { additionalProperties: false });
-const ServerId = typebox.Type.String({ pattern: "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$" });
-const Address = typebox.Type.Object({
-	key: S,
-	generation: typebox.Type.Integer({ minimum: 1 })
-}, { additionalProperties: false });
-const Mode = typebox.Type.Union([typebox.Type.Literal("singleton"), typebox.Type.Literal("keyed")]);
-const SessionTarget = typebox.Type.Object({
-	serverId: ServerId,
-	sessionId: S,
-	attachmentId: S
-}, { additionalProperties: false });
-const Target = typebox.Type.Union([typebox.Type.Object({ serverId: ServerId }, { additionalProperties: false }), SessionTarget]);
-const ChordCallSchema = typebox.Type.Object({
-	serviceId: S,
-	member: S,
-	args: typebox.Type.Array(Json),
-	instance: typebox.Type.Optional(Address)
-}, { additionalProperties: false });
+const Json = typebox.Type.Unknown({ description: "JSON value; its application shape is defined by the addressed contract member." });
+const Id = typebox.Type.Integer({ minimum: 0 });
+const ErrorCode = typebox.Type.Union([
+	"aborted",
+	"contract_mismatch",
+	"forbidden",
+	"gone",
+	"invalid",
+	"not_in_variant",
+	"not_ready",
+	"released",
+	"superseded",
+	"unavailable",
+	"upgrade_conflict",
+	"upgrade_required"
+].map((code) => typebox.Type.Literal(code)));
+const WireError = typebox.Type.Object({
+	code: ErrorCode,
+	message: typebox.Type.String(),
+	reason: typebox.Type.Optional(typebox.Type.String())
+});
 const Segment = typebox.Type.Union([typebox.Type.String(), typebox.Type.Integer({ minimum: 0 })]);
 const Path = typebox.Type.Array(Segment);
 const PathRef = typebox.Type.Union([Path, typebox.Type.Integer({ minimum: 0 })]);
@@ -1871,173 +1840,149 @@ const ChordWireOpSchema = typebox.Type.Union([
 		Index,
 		typebox.Type.Array(Json)
 	]),
+	typebox.Type.Tuple([
+		typebox.Type.Literal("m"),
+		PathRef,
+		typebox.Type.Array(Index)
+	]),
+	typebox.Type.Tuple([typebox.Type.Literal("m"), typebox.Type.Array(Index)]),
 	typebox.Type.Tuple([
 		typebox.Type.Literal("#"),
 		Index,
 		Path
 	])
 ], { description: "Chord delta tuples. Path dictionary references and omitted paths depend on earlier operations in this subscription; decode with the Chord delta decoder." });
-const Instance = typebox.Type.Object({
-	instance: typebox.Type.Optional(Address),
-	members: typebox.Type.Array(typebox.Type.Union([typebox.Type.Object({
-		name: S,
-		kind: typebox.Type.Literal("method")
-	}), typebox.Type.Object({
-		name: S,
-		kind: typebox.Type.Literal("state"),
-		sequence: typebox.Type.Integer({ minimum: 0 }),
-		ops: typebox.Type.Array(ChordWireOpSchema)
-	})]))
+const Ping = typebox.Type.Object({
+	t: typebox.Type.Literal("ping"),
+	n: typebox.Type.Integer()
 });
-const ChordSnapshotSchema = typebox.Type.Object({
-	serviceId: S,
-	mode: Mode,
-	instances: typebox.Type.Array(Instance)
+const Pong = typebox.Type.Object({
+	t: typebox.Type.Literal("pong"),
+	n: typebox.Type.Integer()
 });
-const ChordUpdateSchema = typebox.Type.Union([
+const Bye = typebox.Type.Object({
+	t: typebox.Type.Literal("bye"),
+	reason: typebox.Type.Optional(typebox.Type.String())
+});
+/** Frames a client (browser or native app) sends on its link. */
+const ChordClientFrameSchema = typebox.Type.Union([
 	typebox.Type.Object({
-		type: typebox.Type.Literal("state"),
-		instance: typebox.Type.Optional(Address),
-		member: S,
-		sequence: typebox.Type.Integer({ minimum: 1 }),
-		ops: typebox.Type.Array(ChordWireOpSchema)
+		t: typebox.Type.Literal("hello"),
+		name: typebox.Type.String(),
+		kind: typebox.Type.Literal("client"),
+		epoch: typebox.Type.Integer()
 	}),
-	typebox.Type.Object({ type: typebox.Type.Literal("unavailable") }),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("replaced"),
-		snapshot: Instance
+		t: typebox.Type.Literal("hold"),
+		id: Id,
+		at: typebox.Type.String(),
+		token: Json,
+		input: Json,
+		client: typebox.Type.Optional(typebox.Type.Boolean())
 	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("spawned"),
-		instance: Instance
+		t: typebox.Type.Literal("release"),
+		id: Id
 	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("closed"),
-		instance: Address
-	})
-]);
-const PiClientMessageSchema = typebox.Type.Union([
+		t: typebox.Type.Literal("call"),
+		id: Id,
+		hold: Id,
+		member: S,
+		args: Json
+	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("hello"),
-		version: typebox.Type.Integer({ minimum: 0 })
+		t: typebox.Type.Literal("cancel"),
+		id: Id
 	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("request"),
-		id: S,
-		target: Target,
-		call: ChordCallSchema
+		t: typebox.Type.Literal("sub"),
+		id: Id,
+		hold: Id,
+		member: S
 	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("cancel"),
-		id: S,
-		target: Target
-	})
-]);
-const PiServerMessageSchema = typebox.Type.Union([
+		t: typebox.Type.Literal("unsub"),
+		id: Id
+	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("hello"),
-		version: typebox.Type.Literal(_earendil_works_pi_protocol.PROTOCOL_VERSION),
-		serverId: ServerId
+		t: typebox.Type.Literal("root_end"),
+		rootId: typebox.Type.String()
 	}),
+	Ping,
+	Pong,
+	Bye
+]);
+/** Frames the Po server sends to a client link. */
+const ChordServerFrameSchema = typebox.Type.Union([
 	typebox.Type.Object({
-		type: typebox.Type.Literal("hello_error"),
-		error: E
+		t: typebox.Type.Literal("hello"),
+		name: typebox.Type.String(),
+		kind: typebox.Type.String(),
+		epoch: typebox.Type.Integer()
 	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("response"),
-		id: S,
-		ok: typebox.Type.Literal(true),
-		result: typebox.Type.Optional(Json)
+		t: typebox.Type.Literal("shape"),
+		id: Id,
+		kind: typebox.Type.Optional(typebox.Type.String()),
+		members: typebox.Type.Array(typebox.Type.String()),
+		contract: typebox.Type.String(),
+		epoch: typebox.Type.Integer()
 	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("response"),
-		id: S,
-		ok: typebox.Type.Literal(false),
-		error: E
+		t: typebox.Type.Literal("gone"),
+		id: Id,
+		error: WireError
 	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("service_update"),
-		subscriptionId: S,
-		update: ChordUpdateSchema
+		t: typebox.Type.Literal("result"),
+		id: Id,
+		value: typebox.Type.Optional(Json),
+		error: typebox.Type.Optional(WireError)
 	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("attachment"),
-		attachment: typebox.Type.Union([SessionTarget, typebox.Type.Null()])
-	})
+		t: typebox.Type.Literal("state"),
+		id: Id,
+		snap: typebox.Type.Optional(Json),
+		reset: typebox.Type.Optional(Json),
+		ops: typebox.Type.Optional(typebox.Type.Array(ChordWireOpSchema)),
+		error: typebox.Type.Optional(WireError)
+	}),
+	Ping,
+	Pong,
+	Bye
 ]);
 const transportSocketContracts = [
 	{
-		id: "pi.client",
+		id: "chord.client",
 		scope: "global",
-		service: "$pi",
+		service: "$chord",
 		member: "client",
 		direction: "client-to-server",
 		kind: "channel",
-		input: PiClientMessageSchema,
-		description: `Pi protocol ${_earendil_works_pi_protocol.PROTOCOL_VERSION} decoded client envelope. Encode with the public Pi codec and framing functions, then seal for WebSocket delivery.`
+		input: ChordClientFrameSchema,
+		description: `Chord ${CHORD_WIRE_VERSION} link frame, one JSON text message each, sealed for remote delivery. Hold \`po.hub\` ({}) and \`po.session\` ({ sessionId }) at host \`server\`.`
 	},
 	{
-		id: "pi.server",
+		id: "chord.server",
 		scope: "global",
-		service: "$pi",
+		service: "$chord",
 		member: "server",
 		direction: "server-to-client",
 		kind: "channel",
-		input: PiServerMessageSchema,
-		description: "Pi decoded server envelope. Responses correlate by id; service updates correlate by subscriptionId."
-	},
-	{
-		id: "chord.catalogue",
-		scope: "global",
-		service: "$chord.service",
-		member: "catalogue",
-		direction: "client-to-server",
-		kind: "method",
-		input: typebox.Type.Tuple([]),
-		output: typebox.Type.Array(typebox.Type.Object({
-			serviceId: S,
-			mode: Mode
-		})),
-		errors: E,
-		description: "Discover services at the selected Pi target."
-	},
-	{
-		id: "chord.subscribe",
-		scope: "global",
-		service: "$chord.service",
-		member: "subscribe",
-		direction: "client-to-server",
-		kind: "method",
-		input: typebox.Type.Tuple([
-			S,
-			S,
-			Mode
-		]),
-		output: ChordSnapshotSchema,
-		errors: E,
-		description: "Subscribe with [subscriptionId, serviceId, mode]; subsequent Pi service_update messages contain Chord deltas."
-	},
-	{
-		id: "chord.unsubscribe",
-		scope: "global",
-		service: "$chord.service",
-		member: "unsubscribe",
-		direction: "client-to-server",
-		kind: "method",
-		input: typebox.Type.Tuple([S]),
-		errors: E,
-		description: "Unsubscribe by subscriptionId."
+		input: ChordServerFrameSchema,
+		description: "Chord link frame. Results correlate by call id; state frames by subscription id."
 	},
 	{
 		id: "plugin.invoke",
 		scope: "global",
-		service: "po.plugin.v1",
+		service: "po.hub",
 		member: "invoke",
 		direction: "client-to-server",
 		kind: "method",
-		input: typebox.Type.Tuple([DoomPluginCallSchema]),
+		input: PoPluginCallSchema,
 		output: Json,
-		errors: E,
+		errors: WireError,
 		description: "Invoke the selected scoped plugin method. Its declaration supplies input and output shapes."
 	}
 ];
@@ -2051,8 +1996,7 @@ const builtinApiContract = defineApiContract({
 		SealedHttpResponse: SealedHttpResponseSchema
 	},
 	protocols: {
-		pi: String(_earendil_works_pi_protocol.PROTOCOL_VERSION),
-		chord: "1.0.0",
+		chord: CHORD_WIRE_VERSION,
 		sealed: "1"
 	},
 	http: [
@@ -2072,15 +2016,13 @@ const builtinApiContract = defineApiContract({
 //#endregion
 exports.ApiErrorSchema = ApiErrorSchema;
 exports.ApiOkSchema = ApiOkSchema;
-exports.ChordCallSchema = ChordCallSchema;
-exports.ChordSnapshotSchema = ChordSnapshotSchema;
-exports.ChordUpdateSchema = ChordUpdateSchema;
+exports.CHORD_WIRE_VERSION = CHORD_WIRE_VERSION;
+exports.ChordClientFrameSchema = ChordClientFrameSchema;
+exports.ChordServerFrameSchema = ChordServerFrameSchema;
 exports.ChordWireOpSchema = ChordWireOpSchema;
-exports.DOOM_API_CONTRACT_FILE = DOOM_API_CONTRACT_FILE;
-exports.DOOM_API_CONTRACT_VERSION = DOOM_API_CONTRACT_VERSION;
-exports.DoomApiContractSchema = DoomApiContractSchema;
-exports.PiClientMessageSchema = PiClientMessageSchema;
-exports.PiServerMessageSchema = PiServerMessageSchema;
+exports.PO_API_CONTRACT_FILE = PO_API_CONTRACT_FILE;
+exports.PO_API_CONTRACT_VERSION = PO_API_CONTRACT_VERSION;
+exports.PoApiContractSchema = PoApiContractSchema;
 exports.SessionMethodSchemas = SessionMethodSchemas;
 exports.SessionServiceStateSchema = SessionServiceStateSchema;
 exports.builtinApiContract = builtinApiContract;