@ai-ecoverse/slicc-agent 1.1.0 → 2.0.0

package/README.md

@@ -6,17 +6,32 @@ The package ships unbundled ESM: `dist/` holds one file per source file and impo
 
 ## Use
 
+In the agent's dedicated worker:
+
 ```js
-import { connectAgent, openAgent, serveAgent } from '@ai-ecoverse/slicc-agent';
+import { hostAgent, openAgent, openOpfsSqliteStorage, serveConnections } from '@ai-ecoverse/slicc-agent';
+
+const storage = await openOpfsSqliteStorage();
+serveConnections(self, openAgent({ models, model, storage }).then((agent) => hostAgent(agent)));
+```
 
-serveAgent(self, openAgent({ models, model: { provider: 'amazon-bedrock', modelId } }));
+In the page:
 
-const agent = connectAgent(new Worker(workerUrl, { type: 'module' }));
+```js
+import { startAgent } from '@ai-ecoverse/slicc-agent';
+
+const owner = await startAgent({ worker: () => new Worker(workerUrl, { type: 'module' }) });
+const agent = await owner.connect();
+agent.transcript.subscribe((view) => render(view));
 await agent.prompt('What is in /home?');
 ```
 
-- `openAgent({ models, model, storage?, registry?, settings? })` opens a durable Harness (in memory unless `storage` is given) and its root conversation. `prompt(text)` submits an input and resolves with the answer's text.
-- `serveAgent(endpoint, agent)` answers prompts that arrive on a worker or `MessagePort`; `connectAgent(endpoint)` is the page side.
+- `openAgent({ models, model, storage?, registry?, settings? })` opens a durable Harness (in memory unless `storage` is given) and its root conversation, and resumes work a previous worker left unfinished.
+- `openOpfsSqliteStorage({ directory?, file? })` keeps the session in wasm SQLite ([`@sqlite.org/sqlite-wasm`](https://www.npmjs.com/package/@sqlite.org/sqlite-wasm)) in an `opfs-sahpool` pool, by default `/.slicc/agent/` in OPFS. It needs a dedicated worker. Only one worker holds a pool at a time: the opener takes a Web Lock per directory and waits until every file of the pool can be opened before sqlite-wasm installs it, because a failed install deletes the pool's directory. `openMemorySqliteStorage()` keeps the same database in memory.
+- `hostAgent(agent)` serves the agent with pi's protocol: a pi-server with one session, `agent`, whose Chord services are `slicc.agent.control` (send with `whenBusy` `steer`, `followUp` or `reject`, wait, withdraw, abort, compact) and `slicc.agent.transcript` (the conversation's durable view as replicated state). `serveConnections(self, host)` hands it every `MessagePort` the page sends.
+- `startAgent({ worker })` takes the Web Lock `slicc-agent`, so one tab at a time owns the agent worker, and waits while another tab holds it. `connect()` returns an `AgentConnection` (`control`, `transcript`, `prompt()`), `restart()` replaces the worker (durable resumes from SQLite), and `release()` stops it and lets the next tab take over.
+
+pi-server 1.0.4 calls `unref()` on a `setTimeout` handle when it accepts a connection, which browsers don't have. `PortListener` wraps that one call so its timers get a no-op `unref`.
 
 ## Develop
 

package/dist/client.js

@@ -0,0 +1,64 @@
+import {
+  createRemoteServiceBinding
+} from "@earendil-works/chord";
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { Client, createClientServiceTransport } from "@earendil-works/pi-client";
+import {
+  AGENT_SESSION,
+  AgentControl,
+  AgentSessions,
+  AgentTranscript
+} from "./services.js";
+import { PortChannel } from "./wire.js";
+function attached(client) {
+  return new Promise((resolve) => {
+    const stop = client.onAttachmentChange(() => {
+      stop();
+      resolve();
+    });
+  });
+}
+async function connectAgent(endpoint, options = {}) {
+  const context = options.context ?? BACKGROUND_CONTEXT;
+  const channel = new PortChannel(endpoint);
+  const serverId = await channel.hello;
+  const client = await Client.connect({ serverId, transportFactory: channel.transport });
+  const server = createRemoteServiceBinding({
+    services: [AgentSessions],
+    transport: createClientServiceTransport(client, () => ({ serverId })),
+    bound: true
+  });
+  const ready = attached(client);
+  await server.use(AgentSessions).attach(AGENT_SESSION, context);
+  await ready;
+  const session = createRemoteServiceBinding({
+    services: [AgentControl, AgentTranscript],
+    transport: createClientServiceTransport(client, () => client.attachment),
+    bound: true
+  });
+  const control = session.use(AgentControl);
+  const transcript = session.use(AgentTranscript).state;
+  await session.ready(context);
+  return {
+    serverId,
+    control,
+    transcript,
+    async prompt(text, whenBusy = "followUp") {
+      const sent = await control.send({ text, whenBusy, requestId: null }, context);
+      if (!sent.accepted) throw new Error(`${sent.error.code}: ${sent.error.message}`);
+      const settled = await control.wait(sent.submissionId, context);
+      if (settled.status !== "done") throw new Error(`unanswered: ${settled.reason}`);
+      return settled.text;
+    },
+    async close() {
+      await server.use(AgentSessions).detach(context);
+      await session.dispose(context);
+      await server.dispose(context);
+      await client.dispose();
+    }
+  };
+}
+export {
+  connectAgent
+};
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/client.ts"],
+  "sourcesContent": ["import {\n  type Context,\n  createRemoteServiceBinding,\n  type ReplicatedState,\n} from '@earendil-works/chord';\nimport { BACKGROUND_CONTEXT } from '@earendil-works/chord/context';\nimport { Client, createClientServiceTransport } from '@earendil-works/pi-client';\nimport type { ConversationView } from '@earendil-works/pi-durable';\nimport {\n  AGENT_SESSION,\n  AgentControl,\n  AgentSessions,\n  AgentTranscript,\n  type SendMode,\n} from './services.ts';\nimport { PortChannel, type PortEndpoint } from './wire.ts';\n\nexport interface AgentConnection {\n  readonly serverId: string;\n  readonly control: AgentControl;\n  readonly transcript: ReplicatedState<ConversationView>;\n  prompt(text: string, whenBusy?: SendMode): Promise<string>;\n  close(): Promise<void>;\n}\n\nfunction attached(client: Client): Promise<void> {\n  return new Promise((resolve) => {\n    const stop = client.onAttachmentChange(() => {\n      stop();\n      resolve();\n    });\n  });\n}\n\nexport async function connectAgent(\n  endpoint: PortEndpoint,\n  options: { context?: Context } = {}\n): Promise<AgentConnection> {\n  const context = options.context ?? BACKGROUND_CONTEXT;\n  const channel = new PortChannel(endpoint);\n  const serverId = await channel.hello;\n  const client = await Client.connect({ serverId, transportFactory: channel.transport });\n  const server = createRemoteServiceBinding({\n    services: [AgentSessions],\n    transport: createClientServiceTransport(client, () => ({ serverId })),\n    bound: true,\n  });\n  const ready = attached(client);\n  await server.use(AgentSessions).attach(AGENT_SESSION, context);\n  await ready;\n  const session = createRemoteServiceBinding({\n    services: [AgentControl, AgentTranscript],\n    transport: createClientServiceTransport(client, () => client.attachment),\n    bound: true,\n  });\n  const control = session.use(AgentControl);\n  const transcript = session.use(AgentTranscript).state;\n  await session.ready(context);\n  return {\n    serverId,\n    control,\n    transcript,\n    async prompt(text, whenBusy = 'followUp') {\n      const sent = await control.send({ text, whenBusy, requestId: null }, context);\n      if (!sent.accepted) throw new Error(`${sent.error.code}: ${sent.error.message}`);\n      const settled = await control.wait(sent.submissionId, context);\n      if (settled.status !== 'done') throw new Error(`unanswered: ${settled.reason}`);\n      return settled.text;\n    },\n    async close() {\n      await server.use(AgentSessions).detach(context);\n      await session.dispose(context);\n      await server.dispose(context);\n      await client.dispose();\n    },\n  };\n}\n"],
+  "mappings": "AAAA;AAAA,EAEE;AAAA,OAEK;AACP,SAAS,0BAA0B;AACnC,SAAS,QAAQ,oCAAoC;AAErD;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AACP,SAAS,mBAAsC;AAU/C,SAAS,SAAS,QAA+B;AAC/C,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,UAAM,OAAO,OAAO,mBAAmB,MAAM;AAC3C,WAAK;AACL,cAAQ;AAAA,IACV,CAAC;AAAA,EACH,CAAC;AACH;AAEA,eAAsB,aACpB,UACA,UAAiC,CAAC,GACR;AAC1B,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,UAAU,IAAI,YAAY,QAAQ;AACxC,QAAM,WAAW,MAAM,QAAQ;AAC/B,QAAM,SAAS,MAAM,OAAO,QAAQ,EAAE,UAAU,kBAAkB,QAAQ,UAAU,CAAC;AACrF,QAAM,SAAS,2BAA2B;AAAA,IACxC,UAAU,CAAC,aAAa;AAAA,IACxB,WAAW,6BAA6B,QAAQ,OAAO,EAAE,SAAS,EAAE;AAAA,IACpE,OAAO;AAAA,EACT,CAAC;AACD,QAAM,QAAQ,SAAS,MAAM;AAC7B,QAAM,OAAO,IAAI,aAAa,EAAE,OAAO,eAAe,OAAO;AAC7D,QAAM;AACN,QAAM,UAAU,2BAA2B;AAAA,IACzC,UAAU,CAAC,cAAc,eAAe;AAAA,IACxC,WAAW,6BAA6B,QAAQ,MAAM,OAAO,UAAU;AAAA,IACvE,OAAO;AAAA,EACT,CAAC;AACD,QAAM,UAAU,QAAQ,IAAI,YAAY;AACxC,QAAM,aAAa,QAAQ,IAAI,eAAe,EAAE;AAChD,QAAM,QAAQ,MAAM,OAAO;AAC3B,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM,OAAO,MAAM,WAAW,YAAY;AACxC,YAAM,OAAO,MAAM,QAAQ,KAAK,EAAE,MAAM,UAAU,WAAW,KAAK,GAAG,OAAO;AAC5E,UAAI,CAAC,KAAK,SAAU,OAAM,IAAI,MAAM,GAAG,KAAK,MAAM,IAAI,KAAK,KAAK,MAAM,OAAO,EAAE;AAC/E,YAAM,UAAU,MAAM,QAAQ,KAAK,KAAK,cAAc,OAAO;AAC7D,UAAI,QAAQ,WAAW,OAAQ,OAAM,IAAI,MAAM,eAAe,QAAQ,MAAM,EAAE;AAC9E,aAAO,QAAQ;AAAA,IACjB;AAAA,IACA,MAAM,QAAQ;AACZ,YAAM,OAAO,IAAI,aAAa,EAAE,OAAO,OAAO;AAC9C,YAAM,QAAQ,QAAQ,OAAO;AAC7B,YAAM,OAAO,QAAQ,OAAO;AAC5B,YAAM,OAAO,QAAQ;AAAA,IACvB;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/control.js

@@ -0,0 +1,61 @@
+import {
+  AssistantEntry,
+  ConversationBusy
+} from "@earendil-works/pi-durable";
+import { answerText } from "./agent.js";
+function submissionId(value) {
+  const id = Number(value);
+  return /^[1-9][0-9]*$/.test(value) && Number.isSafeInteger(id) ? id : void 0;
+}
+function operationError(error) {
+  if (error instanceof ConversationBusy) return { code: "busy", message: error.message };
+  return { code: "failed", message: error instanceof Error ? error.message : String(error) };
+}
+async function accepted(operation) {
+  try {
+    const result = await operation();
+    const id = typeof result === "number" ? result : result.id;
+    return { accepted: true, submissionId: String(id), error: null };
+  } catch (error) {
+    return { accepted: false, submissionId: null, error: operationError(error) };
+  }
+}
+function createAgentControl(harness, conversation) {
+  return {
+    send: (request, context) => accepted(
+      () => conversation.submit(
+        {
+          type: "input",
+          content: request.text,
+          whenBusy: request.whenBusy,
+          ...request.requestId ? { requestId: request.requestId } : {}
+        },
+        context
+      )
+    ),
+    async wait(id, context) {
+      const parsed = submissionId(id);
+      const submission = parsed === void 0 ? void 0 : await harness.submission(parsed, context);
+      if (!submission) throw new Error(`unknown submission ${id}`);
+      const settled = await submission.wait(context);
+      const { answer, reason } = settled;
+      if (answer === void 0) return { status: "unanswered", text: null, reason: String(reason) };
+      const entry = await harness.commit((tx) => tx.entry(AssistantEntry, answer), context);
+      return { status: "done", text: answerText(entry?.model?.[0]?.content), reason: null };
+    },
+    async withdraw(id, context) {
+      const parsed = submissionId(id);
+      if (parsed === void 0) return { outcome: "not_found" };
+      const result = await harness.abortSubmission(parsed, context, conversation.id);
+      if (result === "aborted") return { outcome: "withdrawn" };
+      return { outcome: result === "not_found" ? "not_found" : "already_placed" };
+    },
+    abort: (context) => conversation.abort(context),
+    compact: (instructions, context) => accepted(() => conversation.compact(instructions ?? void 0, context))
+  };
+}
+export {
+  createAgentControl,
+  submissionId
+};
+//# sourceMappingURL=control.js.map

package/dist/control.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/control.ts"],
+  "sourcesContent": ["import {\n  AssistantEntry,\n  type Conversation,\n  ConversationBusy,\n  type EntryId,\n  type Harness,\n  type SubmissionId,\n} from '@earendil-works/pi-durable';\nimport { answerText } from './agent.ts';\nimport type { AgentControl, OperationError, SendResponse } from './services.ts';\n\nexport function submissionId(value: string): SubmissionId | undefined {\n  const id = Number(value);\n  return /^[1-9][0-9]*$/.test(value) && Number.isSafeInteger(id) ? (id as SubmissionId) : undefined;\n}\n\nfunction operationError(error: unknown): OperationError {\n  if (error instanceof ConversationBusy) return { code: 'busy', message: error.message };\n  return { code: 'failed', message: error instanceof Error ? error.message : String(error) };\n}\n\nasync function accepted(operation: () => Promise<{ id: number } | number>): Promise<SendResponse> {\n  try {\n    const result = await operation();\n    const id = typeof result === 'number' ? result : result.id;\n    return { accepted: true, submissionId: String(id), error: null };\n  } catch (error) {\n    return { accepted: false, submissionId: null, error: operationError(error) };\n  }\n}\n\nexport function createAgentControl(harness: Harness, conversation: Conversation): AgentControl {\n  return {\n    send: (request, context) =>\n      accepted(() =>\n        conversation.submit(\n          {\n            type: 'input',\n            content: request.text,\n            whenBusy: request.whenBusy,\n            ...(request.requestId ? { requestId: request.requestId } : {}),\n          },\n          context\n        )\n      ),\n    async wait(id, context) {\n      const parsed = submissionId(id);\n      const submission =\n        parsed === undefined ? undefined : await harness.submission(parsed, context);\n      if (!submission) throw new Error(`unknown submission ${id}`);\n      const settled = await submission.wait(context);\n      const { answer, reason } = settled as { answer?: EntryId; reason?: string };\n      if (answer === undefined) return { status: 'unanswered', text: null, reason: String(reason) };\n      const entry = await harness.commit((tx) => tx.entry(AssistantEntry, answer), context);\n      return { status: 'done', text: answerText(entry?.model?.[0]?.content), reason: null };\n    },\n    async withdraw(id, context) {\n      const parsed = submissionId(id);\n      if (parsed === undefined) return { outcome: 'not_found' };\n      const result = await harness.abortSubmission(parsed, context, conversation.id);\n      if (result === 'aborted') return { outcome: 'withdrawn' };\n      return { outcome: result === 'not_found' ? 'not_found' : 'already_placed' };\n    },\n    abort: (context) => conversation.abort(context),\n    compact: (instructions, context) =>\n      accepted(() => conversation.compact(instructions ?? undefined, context)),\n  };\n}\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,EAEA;AAAA,OAIK;AACP,SAAS,kBAAkB;AAGpB,SAAS,aAAa,OAAyC;AACpE,QAAM,KAAK,OAAO,KAAK;AACvB,SAAO,gBAAgB,KAAK,KAAK,KAAK,OAAO,cAAc,EAAE,IAAK,KAAsB;AAC1F;AAEA,SAAS,eAAe,OAAgC;AACtD,MAAI,iBAAiB,iBAAkB,QAAO,EAAE,MAAM,QAAQ,SAAS,MAAM,QAAQ;AACrF,SAAO,EAAE,MAAM,UAAU,SAAS,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,EAAE;AAC3F;AAEA,eAAe,SAAS,WAA0E;AAChG,MAAI;AACF,UAAM,SAAS,MAAM,UAAU;AAC/B,UAAM,KAAK,OAAO,WAAW,WAAW,SAAS,OAAO;AACxD,WAAO,EAAE,UAAU,MAAM,cAAc,OAAO,EAAE,GAAG,OAAO,KAAK;AAAA,EACjE,SAAS,OAAO;AACd,WAAO,EAAE,UAAU,OAAO,cAAc,MAAM,OAAO,eAAe,KAAK,EAAE;AAAA,EAC7E;AACF;AAEO,SAAS,mBAAmB,SAAkB,cAA0C;AAC7F,SAAO;AAAA,IACL,MAAM,CAAC,SAAS,YACd;AAAA,MAAS,MACP,aAAa;AAAA,QACX;AAAA,UACE,MAAM;AAAA,UACN,SAAS,QAAQ;AAAA,UACjB,UAAU,QAAQ;AAAA,UAClB,GAAI,QAAQ,YAAY,EAAE,WAAW,QAAQ,UAAU,IAAI,CAAC;AAAA,QAC9D;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA,IACF,MAAM,KAAK,IAAI,SAAS;AACtB,YAAM,SAAS,aAAa,EAAE;AAC9B,YAAM,aACJ,WAAW,SAAY,SAAY,MAAM,QAAQ,WAAW,QAAQ,OAAO;AAC7E,UAAI,CAAC,WAAY,OAAM,IAAI,MAAM,sBAAsB,EAAE,EAAE;AAC3D,YAAM,UAAU,MAAM,WAAW,KAAK,OAAO;AAC7C,YAAM,EAAE,QAAQ,OAAO,IAAI;AAC3B,UAAI,WAAW,OAAW,QAAO,EAAE,QAAQ,cAAc,MAAM,MAAM,QAAQ,OAAO,MAAM,EAAE;AAC5F,YAAM,QAAQ,MAAM,QAAQ,OAAO,CAAC,OAAO,GAAG,MAAM,gBAAgB,MAAM,GAAG,OAAO;AACpF,aAAO,EAAE,QAAQ,QAAQ,MAAM,WAAW,OAAO,QAAQ,CAAC,GAAG,OAAO,GAAG,QAAQ,KAAK;AAAA,IACtF;AAAA,IACA,MAAM,SAAS,IAAI,SAAS;AAC1B,YAAM,SAAS,aAAa,EAAE;AAC9B,UAAI,WAAW,OAAW,QAAO,EAAE,SAAS,YAAY;AACxD,YAAM,SAAS,MAAM,QAAQ,gBAAgB,QAAQ,SAAS,aAAa,EAAE;AAC7E,UAAI,WAAW,UAAW,QAAO,EAAE,SAAS,YAAY;AACxD,aAAO,EAAE,SAAS,WAAW,cAAc,cAAc,iBAAiB;AAAA,IAC5E;AAAA,IACA,OAAO,CAAC,YAAY,aAAa,MAAM,OAAO;AAAA,IAC9C,SAAS,CAAC,cAAc,YACtB,SAAS,MAAM,aAAa,QAAQ,gBAAgB,QAAW,OAAO,CAAC;AAAA,EAC3E;AACF;",
+  "names": []
+}

package/dist/host.js

@@ -0,0 +1,82 @@
+import {
+  createRemoteServiceEndpoint,
+  RemoteServiceProvider
+} from "@earendil-works/chord";
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import {
+  Server,
+  SessionNotFoundError
+} from "@earendil-works/pi-server";
+import { createAgentControl } from "./control.js";
+import { AGENT_SESSION, AgentControl, AgentSessions, AgentTranscript } from "./services.js";
+import { PortListener } from "./wire.js";
+function endpointFor(provider) {
+  const endpoint = createRemoteServiceEndpoint(provider);
+  return {
+    invokeService: (call, publish, context) => endpoint.invoke(call, (id, update) => publish(id, update, context), context),
+    release: () => endpoint.dispose()
+  };
+}
+function sessionServices(provider) {
+  return {
+    attachClient: () => endpointFor(provider),
+    close: async () => {
+    }
+  };
+}
+function serverServices() {
+  return {
+    attachClient(presentation) {
+      const provider = new RemoteServiceProvider([{ service: AgentSessions, mode: "singleton" }]);
+      provider.provide(AgentSessions, {
+        attach: (sessionId, context) => presentation.attachSession(sessionId, context),
+        detach: (context) => presentation.detachSession(context)
+      });
+      const attachment = endpointFor(provider);
+      return {
+        invokeService: attachment.invokeService,
+        release(context) {
+          attachment.release(context);
+          provider.dispose();
+        }
+      };
+    }
+  };
+}
+async function hostAgent(agent, options = {}) {
+  const context = options.context ?? BACKGROUND_CONTEXT;
+  const serverId = options.serverId ?? crypto.randomUUID();
+  const state = await agent.root.viewState(context);
+  const provider = new RemoteServiceProvider([
+    { service: AgentControl, mode: "singleton" },
+    { service: AgentTranscript, mode: "singleton" }
+  ]);
+  provider.provide(AgentControl, createAgentControl(agent.harness, agent.root));
+  provider.provide(AgentTranscript, { state });
+  const host = {
+    serverServices: serverServices(),
+    async resolveSession(sessionId) {
+      if (sessionId !== AGENT_SESSION)
+        throw new SessionNotFoundError(`unknown session ${sessionId}`);
+      return { id: sessionId };
+    },
+    openSession: async () => sessionServices(provider)
+  };
+  const listener = new PortListener(serverId);
+  const server = await new Server(host, { serverId, listeners: [listener] }).start();
+  return {
+    serverId,
+    agent,
+    connect: (endpoint) => listener.connect(endpoint),
+    async close() {
+      await server.close();
+      provider.dispose();
+      state.dispose();
+      await agent.close();
+    }
+  };
+}
+export {
+  hostAgent
+};
+//# sourceMappingURL=host.js.map

package/dist/host.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/host.ts"],
+  "sourcesContent": ["import {\n  type Context,\n  createRemoteServiceEndpoint,\n  RemoteServiceProvider,\n} from '@earendil-works/chord';\nimport { BACKGROUND_CONTEXT } from '@earendil-works/chord/context';\nimport {\n  type RoutedServerServiceHost,\n  type RoutedSessionAttachment,\n  type RoutedSessionHandle,\n  Server,\n  type ServerHost,\n  SessionNotFoundError,\n} from '@earendil-works/pi-server';\nimport type { Agent } from './agent.ts';\nimport { createAgentControl } from './control.ts';\nimport { AGENT_SESSION, AgentControl, AgentSessions, AgentTranscript } from './services.ts';\nimport { type PortEndpoint, PortListener } from './wire.ts';\n\nexport interface AgentHost {\n  readonly serverId: string;\n  readonly agent: Agent;\n  connect(endpoint: PortEndpoint): void;\n  close(): Promise<void>;\n}\n\nfunction endpointFor(provider: RemoteServiceProvider): RoutedSessionAttachment {\n  const endpoint = createRemoteServiceEndpoint(provider);\n  return {\n    invokeService: (call, publish, context) =>\n      endpoint.invoke(call, (id, update) => publish(id, update, context), context),\n    release: () => endpoint.dispose(),\n  };\n}\n\nfunction sessionServices(provider: RemoteServiceProvider): RoutedSessionHandle {\n  return {\n    attachClient: () => endpointFor(provider),\n    close: async () => {},\n  };\n}\n\nfunction serverServices(): RoutedServerServiceHost {\n  return {\n    attachClient(presentation) {\n      const provider = new RemoteServiceProvider([{ service: AgentSessions, mode: 'singleton' }]);\n      provider.provide(AgentSessions, {\n        attach: (sessionId, context) => presentation.attachSession(sessionId, context),\n        detach: (context) => presentation.detachSession(context),\n      });\n      const attachment = endpointFor(provider);\n      return {\n        invokeService: attachment.invokeService,\n        release(context) {\n          attachment.release(context);\n          provider.dispose();\n        },\n      };\n    },\n  };\n}\n\nexport async function hostAgent(\n  agent: Agent,\n  options: { serverId?: string; context?: Context } = {}\n): Promise<AgentHost> {\n  const context = options.context ?? BACKGROUND_CONTEXT;\n  const serverId = options.serverId ?? crypto.randomUUID();\n  const state = await agent.root.viewState(context);\n  const provider = new RemoteServiceProvider([\n    { service: AgentControl, mode: 'singleton' },\n    { service: AgentTranscript, mode: 'singleton' },\n  ]);\n  provider.provide(AgentControl, createAgentControl(agent.harness, agent.root));\n  provider.provide(AgentTranscript, { state });\n  const host: ServerHost = {\n    serverServices: serverServices(),\n    async resolveSession(sessionId) {\n      if (sessionId !== AGENT_SESSION)\n        throw new SessionNotFoundError(`unknown session ${sessionId}`);\n      return { id: sessionId };\n    },\n    openSession: async () => sessionServices(provider),\n  };\n  const listener = new PortListener(serverId);\n  const server = await new Server(host, { serverId, listeners: [listener] }).start();\n  return {\n    serverId,\n    agent,\n    connect: (endpoint) => listener.connect(endpoint),\n    async close() {\n      await server.close();\n      provider.dispose();\n      state.dispose();\n      await agent.close();\n    },\n  };\n}\n"],
+  "mappings": "AAAA;AAAA,EAEE;AAAA,EACA;AAAA,OACK;AACP,SAAS,0BAA0B;AACnC;AAAA,EAIE;AAAA,EAEA;AAAA,OACK;AAEP,SAAS,0BAA0B;AACnC,SAAS,eAAe,cAAc,eAAe,uBAAuB;AAC5E,SAA4B,oBAAoB;AAShD,SAAS,YAAY,UAA0D;AAC7E,QAAM,WAAW,4BAA4B,QAAQ;AACrD,SAAO;AAAA,IACL,eAAe,CAAC,MAAM,SAAS,YAC7B,SAAS,OAAO,MAAM,CAAC,IAAI,WAAW,QAAQ,IAAI,QAAQ,OAAO,GAAG,OAAO;AAAA,IAC7E,SAAS,MAAM,SAAS,QAAQ;AAAA,EAClC;AACF;AAEA,SAAS,gBAAgB,UAAsD;AAC7E,SAAO;AAAA,IACL,cAAc,MAAM,YAAY,QAAQ;AAAA,IACxC,OAAO,YAAY;AAAA,IAAC;AAAA,EACtB;AACF;AAEA,SAAS,iBAA0C;AACjD,SAAO;AAAA,IACL,aAAa,cAAc;AACzB,YAAM,WAAW,IAAI,sBAAsB,CAAC,EAAE,SAAS,eAAe,MAAM,YAAY,CAAC,CAAC;AAC1F,eAAS,QAAQ,eAAe;AAAA,QAC9B,QAAQ,CAAC,WAAW,YAAY,aAAa,cAAc,WAAW,OAAO;AAAA,QAC7E,QAAQ,CAAC,YAAY,aAAa,cAAc,OAAO;AAAA,MACzD,CAAC;AACD,YAAM,aAAa,YAAY,QAAQ;AACvC,aAAO;AAAA,QACL,eAAe,WAAW;AAAA,QAC1B,QAAQ,SAAS;AACf,qBAAW,QAAQ,OAAO;AAC1B,mBAAS,QAAQ;AAAA,QACnB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAEA,eAAsB,UACpB,OACA,UAAoD,CAAC,GACjC;AACpB,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,WAAW,QAAQ,YAAY,OAAO,WAAW;AACvD,QAAM,QAAQ,MAAM,MAAM,KAAK,UAAU,OAAO;AAChD,QAAM,WAAW,IAAI,sBAAsB;AAAA,IACzC,EAAE,SAAS,cAAc,MAAM,YAAY;AAAA,IAC3C,EAAE,SAAS,iBAAiB,MAAM,YAAY;AAAA,EAChD,CAAC;AACD,WAAS,QAAQ,cAAc,mBAAmB,MAAM,SAAS,MAAM,IAAI,CAAC;AAC5E,WAAS,QAAQ,iBAAiB,EAAE,MAAM,CAAC;AAC3C,QAAM,OAAmB;AAAA,IACvB,gBAAgB,eAAe;AAAA,IAC/B,MAAM,eAAe,WAAW;AAC9B,UAAI,cAAc;AAChB,cAAM,IAAI,qBAAqB,mBAAmB,SAAS,EAAE;AAC/D,aAAO,EAAE,IAAI,UAAU;AAAA,IACzB;AAAA,IACA,aAAa,YAAY,gBAAgB,QAAQ;AAAA,EACnD;AACA,QAAM,WAAW,IAAI,aAAa,QAAQ;AAC1C,QAAM,SAAS,MAAM,IAAI,OAAO,MAAM,EAAE,UAAU,WAAW,CAAC,QAAQ,EAAE,CAAC,EAAE,MAAM;AACjF,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,SAAS,CAAC,aAAa,SAAS,QAAQ,QAAQ;AAAA,IAChD,MAAM,QAAQ;AACZ,YAAM,OAAO,MAAM;AACnB,eAAS,QAAQ;AACjB,YAAM,QAAQ;AACd,YAAM,MAAM,MAAM;AAAA,IACpB;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/index.js

@@ -1,12 +1,44 @@
 import { answerText, openAgent } from "./agent.js";
+import { connectAgent } from "./client.js";
+import { createAgentControl } from "./control.js";
+import { hostAgent } from "./host.js";
 import {
-  connectAgent,
-  serveAgent
-} from "./port.js";
+  AGENT_LOCK,
+  startAgent
+} from "./owner.js";
+import {
+  AGENT_SESSION,
+  AgentControl,
+  AgentSessions,
+  AgentTranscript
+} from "./services.js";
+import {
+  AGENT_DIRECTORY,
+  openMemorySqliteStorage,
+  openOpfsSqliteStorage,
+  WasmSqliteDatabase
+} from "./sqlite.js";
+import { PortChannel, PortListener, withUnrefTimers } from "./wire.js";
+import { serveConnections } from "./worker.js";
 export {
+  AGENT_DIRECTORY,
+  AGENT_LOCK,
+  AGENT_SESSION,
+  AgentControl,
+  AgentSessions,
+  AgentTranscript,
+  PortChannel,
+  PortListener,
+  WasmSqliteDatabase,
   answerText,
   connectAgent,
+  createAgentControl,
+  hostAgent,
   openAgent,
-  serveAgent
+  openMemorySqliteStorage,
+  openOpfsSqliteStorage,
+  serveConnections,
+  startAgent,
+  withUnrefTimers
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/index.ts"],
-  "sourcesContent": ["export { type Agent, type AgentOptions, answerText, openAgent } from './agent.ts';\nexport {\n  type AgentClient,\n  type AgentReply,\n  type AgentRequest,\n  connectAgent,\n  type MessageEndpoint,\n  serveAgent,\n} from './port.ts';\n"],
-  "mappings": "AAAA,SAAwC,YAAY,iBAAiB;AACrE;AAAA,EAIE;AAAA,EAEA;AAAA,OACK;",
+  "sourcesContent": ["export { type Agent, type AgentOptions, answerText, openAgent } from './agent.ts';\nexport { type AgentConnection, connectAgent } from './client.ts';\nexport { createAgentControl } from './control.ts';\nexport { type AgentHost, hostAgent } from './host.ts';\nexport {\n  AGENT_LOCK,\n  type AgentOwner,\n  type AgentWorker,\n  type OwnerOptions,\n  startAgent,\n} from './owner.ts';\nexport {\n  AGENT_SESSION,\n  AgentControl,\n  AgentSessions,\n  AgentTranscript,\n  type OperationError,\n  type PromptResult,\n  type SendMode,\n  type SendRequest,\n  type SendResponse,\n} from './services.ts';\nexport {\n  AGENT_DIRECTORY,\n  type OpfsSqliteOptions,\n  openMemorySqliteStorage,\n  openOpfsSqliteStorage,\n  WasmSqliteDatabase,\n} from './sqlite.ts';\nexport { PortChannel, type PortEndpoint, PortListener, withUnrefTimers } from './wire.ts';\nexport { serveConnections, type WorkerScope } from './worker.ts';\n"],
+  "mappings": "AAAA,SAAwC,YAAY,iBAAiB;AACrE,SAA+B,oBAAoB;AACnD,SAAS,0BAA0B;AACnC,SAAyB,iBAAiB;AAC1C;AAAA,EACE;AAAA,EAIA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAMK;AACP;AAAA,EACE;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,aAAgC,cAAc,uBAAuB;AAC9E,SAAS,wBAA0C;",
   "names": []
 }

package/dist/opfs-pool.js

@@ -0,0 +1,55 @@
+const names = /* @__PURE__ */ new Map();
+function vfsName(directory) {
+  let name = names.get(directory);
+  if (!name) {
+    name = `slicc-agent-${names.size}`;
+    names.set(directory, name);
+  }
+  return name;
+}
+function holdLock(locks, name) {
+  return new Promise((acquired, failed) => {
+    locks.request(name, { mode: "exclusive" }, () => new Promise((release) => acquired(release))).catch(failed);
+  });
+}
+async function opaque(root, directory) {
+  let dir = root;
+  try {
+    for (const part of [...directory.split("/").filter(Boolean), ".opaque"]) {
+      dir = await dir.getDirectoryHandle(part);
+    }
+  } catch {
+    return void 0;
+  }
+  return dir;
+}
+async function acquirable(dir) {
+  for await (const handle of dir.values()) {
+    if (handle.kind !== "file") continue;
+    try {
+      const access = await handle.createSyncAccessHandle();
+      access.close();
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+const pause = (ms) => new Promise((resume) => setTimeout(resume, ms));
+async function settlePool(directory, access = {}) {
+  const root = await (access.root ?? (() => navigator.storage.getDirectory()))();
+  const dir = await opaque(root, directory);
+  if (!dir) return;
+  const attempts = access.attempts ?? 50;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    if (await acquirable(dir)) return;
+    if (attempt < attempts) await pause(access.delayMs ?? 100);
+  }
+  throw new Error(`SQLite pool ${directory} is still in use by another worker`);
+}
+export {
+  holdLock,
+  settlePool,
+  vfsName
+};
+//# sourceMappingURL=opfs-pool.js.map

package/dist/opfs-pool.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/opfs-pool.ts"],
+  "sourcesContent": ["export interface PoolAccess {\n  root?: () => Promise<FileSystemDirectoryHandle>;\n  locks?: LockManager;\n  attempts?: number;\n  delayMs?: number;\n}\n\ninterface SyncAccessible {\n  createSyncAccessHandle(): Promise<{ close(): void }>;\n}\n\nconst names = new Map<string, string>();\n\nexport function vfsName(directory: string): string {\n  let name = names.get(directory);\n  if (!name) {\n    name = `slicc-agent-${names.size}`;\n    names.set(directory, name);\n  }\n  return name;\n}\n\nexport function holdLock(locks: LockManager, name: string): Promise<() => void> {\n  return new Promise((acquired, failed) => {\n    locks\n      .request(name, { mode: 'exclusive' }, () => new Promise<void>((release) => acquired(release)))\n      .catch(failed);\n  });\n}\n\nasync function opaque(\n  root: FileSystemDirectoryHandle,\n  directory: string\n): Promise<FileSystemDirectoryHandle | undefined> {\n  let dir = root;\n  try {\n    for (const part of [...directory.split('/').filter(Boolean), '.opaque']) {\n      dir = await dir.getDirectoryHandle(part);\n    }\n  } catch {\n    return undefined;\n  }\n  return dir;\n}\n\nasync function acquirable(dir: FileSystemDirectoryHandle): Promise<boolean> {\n  for await (const handle of dir.values()) {\n    if (handle.kind !== 'file') continue;\n    try {\n      const access = await (handle as unknown as SyncAccessible).createSyncAccessHandle();\n      access.close();\n    } catch {\n      return false;\n    }\n  }\n  return true;\n}\n\nconst pause = (ms: number) => new Promise((resume) => setTimeout(resume, ms));\n\nexport async function settlePool(directory: string, access: PoolAccess = {}): Promise<void> {\n  const root = await (access.root ?? (() => navigator.storage.getDirectory()))();\n  const dir = await opaque(root, directory);\n  if (!dir) return;\n  const attempts = access.attempts ?? 50;\n  for (let attempt = 1; attempt <= attempts; attempt++) {\n    if (await acquirable(dir)) return;\n    if (attempt < attempts) await pause(access.delayMs ?? 100);\n  }\n  throw new Error(`SQLite pool ${directory} is still in use by another worker`);\n}\n"],
+  "mappings": "AAWA,MAAM,QAAQ,oBAAI,IAAoB;AAE/B,SAAS,QAAQ,WAA2B;AACjD,MAAI,OAAO,MAAM,IAAI,SAAS;AAC9B,MAAI,CAAC,MAAM;AACT,WAAO,eAAe,MAAM,IAAI;AAChC,UAAM,IAAI,WAAW,IAAI;AAAA,EAC3B;AACA,SAAO;AACT;AAEO,SAAS,SAAS,OAAoB,MAAmC;AAC9E,SAAO,IAAI,QAAQ,CAAC,UAAU,WAAW;AACvC,UACG,QAAQ,MAAM,EAAE,MAAM,YAAY,GAAG,MAAM,IAAI,QAAc,CAAC,YAAY,SAAS,OAAO,CAAC,CAAC,EAC5F,MAAM,MAAM;AAAA,EACjB,CAAC;AACH;AAEA,eAAe,OACb,MACA,WACgD;AAChD,MAAI,MAAM;AACV,MAAI;AACF,eAAW,QAAQ,CAAC,GAAG,UAAU,MAAM,GAAG,EAAE,OAAO,OAAO,GAAG,SAAS,GAAG;AACvE,YAAM,MAAM,IAAI,mBAAmB,IAAI;AAAA,IACzC;AAAA,EACF,QAAQ;AACN,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAEA,eAAe,WAAW,KAAkD;AAC1E,mBAAiB,UAAU,IAAI,OAAO,GAAG;AACvC,QAAI,OAAO,SAAS,OAAQ;AAC5B,QAAI;AACF,YAAM,SAAS,MAAO,OAAqC,uBAAuB;AAClF,aAAO,MAAM;AAAA,IACf,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAEA,MAAM,QAAQ,CAAC,OAAe,IAAI,QAAQ,CAAC,WAAW,WAAW,QAAQ,EAAE,CAAC;AAE5E,eAAsB,WAAW,WAAmB,SAAqB,CAAC,GAAkB;AAC1F,QAAM,OAAO,OAAO,OAAO,SAAS,MAAM,UAAU,QAAQ,aAAa,IAAI;AAC7E,QAAM,MAAM,MAAM,OAAO,MAAM,SAAS;AACxC,MAAI,CAAC,IAAK;AACV,QAAM,WAAW,OAAO,YAAY;AACpC,WAAS,UAAU,GAAG,WAAW,UAAU,WAAW;AACpD,QAAI,MAAM,WAAW,GAAG,EAAG;AAC3B,QAAI,UAAU,SAAU,OAAM,MAAM,OAAO,WAAW,GAAG;AAAA,EAC3D;AACA,QAAM,IAAI,MAAM,eAAe,SAAS,oCAAoC;AAC9E;",
+  "names": []
+}

package/dist/owner.js

@@ -0,0 +1,34 @@
+import { connectAgent } from "./client.js";
+import { holdLock } from "./opfs-pool.js";
+const AGENT_LOCK = "slicc-agent";
+async function startAgent(options) {
+  const release = await holdLock(options.locks ?? navigator.locks, AGENT_LOCK);
+  const channel = options.channel ?? (() => new MessageChannel());
+  let worker;
+  try {
+    worker = options.worker();
+  } catch (error) {
+    release();
+    throw error;
+  }
+  return {
+    connect() {
+      const { port1, port2 } = channel();
+      worker.postMessage({ connect: port2 }, [port2]);
+      return connectAgent(port1);
+    },
+    restart() {
+      worker.terminate();
+      worker = options.worker();
+    },
+    release() {
+      worker.terminate();
+      release();
+    }
+  };
+}
+export {
+  AGENT_LOCK,
+  startAgent
+};
+//# sourceMappingURL=owner.js.map

package/dist/owner.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/owner.ts"],
+  "sourcesContent": ["import { type AgentConnection, connectAgent } from './client.ts';\nimport { holdLock } from './opfs-pool.ts';\nimport type { PortEndpoint } from './wire.ts';\n\nexport const AGENT_LOCK = 'slicc-agent';\n\nexport interface AgentWorker {\n  postMessage(message: unknown, transfer: Transferable[]): void;\n  terminate(): void;\n}\n\nexport interface AgentOwner {\n  connect(): Promise<AgentConnection>;\n  restart(): void;\n  release(): void;\n}\n\nexport interface OwnerOptions {\n  worker: () => AgentWorker;\n  locks?: LockManager;\n  channel?: () => { port1: PortEndpoint; port2: Transferable };\n}\n\nexport async function startAgent(options: OwnerOptions): Promise<AgentOwner> {\n  const release = await holdLock(options.locks ?? navigator.locks, AGENT_LOCK);\n  const channel = options.channel ?? (() => new MessageChannel());\n  let worker: AgentWorker;\n  try {\n    worker = options.worker();\n  } catch (error) {\n    release();\n    throw error;\n  }\n  return {\n    connect() {\n      const { port1, port2 } = channel();\n      worker.postMessage({ connect: port2 }, [port2]);\n      return connectAgent(port1);\n    },\n    restart() {\n      worker.terminate();\n      worker = options.worker();\n    },\n    release() {\n      worker.terminate();\n      release();\n    },\n  };\n}\n"],
+  "mappings": "AAAA,SAA+B,oBAAoB;AACnD,SAAS,gBAAgB;AAGlB,MAAM,aAAa;AAmB1B,eAAsB,WAAW,SAA4C;AAC3E,QAAM,UAAU,MAAM,SAAS,QAAQ,SAAS,UAAU,OAAO,UAAU;AAC3E,QAAM,UAAU,QAAQ,YAAY,MAAM,IAAI,eAAe;AAC7D,MAAI;AACJ,MAAI;AACF,aAAS,QAAQ,OAAO;AAAA,EAC1B,SAAS,OAAO;AACd,YAAQ;AACR,UAAM;AAAA,EACR;AACA,SAAO;AAAA,IACL,UAAU;AACR,YAAM,EAAE,OAAO,MAAM,IAAI,QAAQ;AACjC,aAAO,YAAY,EAAE,SAAS,MAAM,GAAG,CAAC,KAAK,CAAC;AAC9C,aAAO,aAAa,KAAK;AAAA,IAC3B;AAAA,IACA,UAAU;AACR,aAAO,UAAU;AACjB,eAAS,QAAQ,OAAO;AAAA,IAC1B;AAAA,IACA,UAAU;AACR,aAAO,UAAU;AACjB,cAAQ;AAAA,IACV;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/services.js

@@ -0,0 +1,12 @@
+import { defineService } from "@earendil-works/chord";
+const AgentControl = defineService("slicc.agent.control");
+const AgentTranscript = defineService("slicc.agent.transcript");
+const AgentSessions = defineService("slicc.agent.sessions");
+const AGENT_SESSION = "agent";
+export {
+  AGENT_SESSION,
+  AgentControl,
+  AgentSessions,
+  AgentTranscript
+};
+//# sourceMappingURL=services.js.map

package/dist/services.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/services.ts"],
+  "sourcesContent": ["import { type Context, defineService, type ReplicatedState } from '@earendil-works/chord';\nimport type { ConversationView } from '@earendil-works/pi-durable';\n\nexport type SendMode = 'steer' | 'followUp' | 'reject';\n\nexport interface SendRequest {\n  text: string;\n  whenBusy: SendMode;\n  requestId: string | null;\n}\n\nexport interface OperationError {\n  code: string;\n  message: string;\n}\n\nexport type SendResponse =\n  | { accepted: true; submissionId: string; error: null }\n  | { accepted: false; submissionId: null; error: OperationError };\n\nexport type PromptResult =\n  | { status: 'done'; text: string; reason: null }\n  | { status: 'unanswered'; text: null; reason: string };\n\nexport interface AgentControl {\n  send(request: SendRequest, context: Context): Promise<SendResponse>;\n  wait(submissionId: string, context: Context): Promise<PromptResult>;\n  withdraw(\n    submissionId: string,\n    context: Context\n  ): Promise<{ outcome: 'withdrawn' | 'already_placed' | 'not_found' }>;\n  abort(context: Context): Promise<void>;\n  compact(instructions: string | null, context: Context): Promise<SendResponse>;\n}\n\nexport const AgentControl = defineService<AgentControl>('slicc.agent.control');\n\nexport interface AgentTranscript {\n  readonly state: ReplicatedState<ConversationView>;\n}\n\nexport const AgentTranscript = defineService<AgentTranscript>('slicc.agent.transcript');\n\nexport interface AgentSessions {\n  attach(sessionId: string, context: Context): Promise<void>;\n  detach(context: Context): Promise<void>;\n}\n\nexport const AgentSessions = defineService<AgentSessions>('slicc.agent.sessions');\n\nexport const AGENT_SESSION = 'agent';\n"],
+  "mappings": "AAAA,SAAuB,qBAA2C;AAmC3D,MAAM,eAAe,cAA4B,qBAAqB;AAMtE,MAAM,kBAAkB,cAA+B,wBAAwB;AAO/E,MAAM,gBAAgB,cAA6B,sBAAsB;AAEzE,MAAM,gBAAgB;",
+  "names": []
+}

package/dist/sqlite.js

@@ -0,0 +1,158 @@
+import {
+  SqliteStorage
+} from "@earendil-works/pi-durable/storage/sqlite";
+import init, {} from "@sqlite.org/sqlite-wasm";
+import { holdLock, settlePool, vfsName } from "./opfs-pool.js";
+class SerialQueue {
+  #tail = Promise.resolve();
+  run(operation) {
+    const result = this.#tail.then(operation);
+    this.#tail = result.catch(() => {
+    });
+    return result;
+  }
+}
+class Statements {
+  #db;
+  #cache = /* @__PURE__ */ new Map();
+  constructor(db) {
+    this.#db = db;
+  }
+  bound(sql, params) {
+    let statement = this.#cache.get(sql);
+    if (!statement) {
+      statement = this.#db.prepare(sql);
+      this.#cache.set(sql, statement);
+    }
+    statement.reset(true);
+    if (params.length > 0) statement.bind([...params]);
+    return statement;
+  }
+  finalize() {
+    for (const statement of this.#cache.values()) statement.finalize();
+    this.#cache.clear();
+  }
+}
+class WasmSqliteExecutor {
+  db;
+  statements;
+  constructor(db, statements) {
+    this.db = db;
+    this.statements = statements;
+  }
+  async exec(sql) {
+    this.check();
+    this.db.exec(sql);
+  }
+  async run(sql, ...params) {
+    this.check();
+    this.statements.bound(sql, params).stepReset();
+  }
+  async get(sql, ...params) {
+    this.check();
+    const statement = this.statements.bound(sql, params);
+    const row = statement.step() ? statement.get({}) : void 0;
+    statement.reset();
+    return row;
+  }
+  async all(sql, ...params) {
+    this.check();
+    const statement = this.statements.bound(sql, params);
+    const rows = [];
+    while (statement.step()) rows.push(statement.get({}));
+    statement.reset();
+    return rows;
+  }
+  check() {
+  }
+}
+class WasmSqliteTransaction extends WasmSqliteExecutor {
+  active = true;
+  check() {
+    if (!this.active) throw new Error("SQLite transaction handle is no longer active");
+  }
+}
+class WasmSqliteDatabase extends WasmSqliteExecutor {
+  #queue = new SerialQueue();
+  #closed;
+  constructor(db, closed = () => {
+  }) {
+    super(db, new Statements(db));
+    this.#closed = closed;
+  }
+  exec(sql) {
+    return this.#queue.run(() => super.exec(sql));
+  }
+  run(sql, ...params) {
+    return this.#queue.run(() => super.run(sql, ...params));
+  }
+  get(sql, ...params) {
+    return this.#queue.run(() => super.get(sql, ...params));
+  }
+  all(sql, ...params) {
+    return this.#queue.run(() => super.all(sql, ...params));
+  }
+  transaction(callback) {
+    return this.#queue.run(async () => {
+      const transaction = new WasmSqliteTransaction(this.db, this.statements);
+      this.db.exec("BEGIN IMMEDIATE");
+      try {
+        const result = await callback(transaction);
+        this.db.exec("COMMIT");
+        return result;
+      } catch (error) {
+        this.#rollback(error);
+        throw error;
+      } finally {
+        transaction.active = false;
+      }
+    });
+  }
+  close() {
+    return this.#queue.run(() => {
+      try {
+        this.statements.finalize();
+        this.db.close();
+      } finally {
+        this.#closed();
+      }
+    });
+  }
+  #rollback(cause) {
+    try {
+      this.db.exec("ROLLBACK");
+    } catch (error) {
+      throw new AggregateError([cause, error], "SQLite rollback failed");
+    }
+  }
+}
+const AGENT_DIRECTORY = "/.slicc/agent";
+async function openMemorySqliteStorage() {
+  const sqlite3 = await init();
+  return SqliteStorage.open(new WasmSqliteDatabase(new sqlite3.oo1.DB(":memory:", "c")));
+}
+async function openOpfsSqliteStorage(options = {}) {
+  const directory = options.directory ?? AGENT_DIRECTORY;
+  const release = await holdLock(
+    options.locks ?? navigator.locks,
+    `slicc-agent-sqlite:${directory}`
+  );
+  try {
+    await settlePool(directory, options);
+    const sqlite3 = await (options.load ?? init)();
+    const pool = await sqlite3.installOpfsSAHPoolVfs({ name: vfsName(directory), directory });
+    const db = new pool.OpfsSAHPoolDb(options.file ?? "/agent.sqlite");
+    db.exec("PRAGMA journal_mode = TRUNCATE");
+    return await SqliteStorage.open(new WasmSqliteDatabase(db, release));
+  } catch (error) {
+    release();
+    throw error;
+  }
+}
+export {
+  AGENT_DIRECTORY,
+  WasmSqliteDatabase,
+  openMemorySqliteStorage,
+  openOpfsSqliteStorage
+};
+//# sourceMappingURL=sqlite.js.map

package/dist/sqlite.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/sqlite.ts"],
+  "sourcesContent": ["import type { Storage } from '@earendil-works/pi-durable';\nimport {\n  type SqliteDatabase,\n  type SqliteExecutor,\n  SqliteStorage,\n  type SqliteValue,\n} from '@earendil-works/pi-durable/storage/sqlite';\nimport init, { type Database, type PreparedStatement } from '@sqlite.org/sqlite-wasm';\nimport { holdLock, type PoolAccess, settlePool, vfsName } from './opfs-pool.ts';\n\ntype Row = Record<string, unknown>;\n\nclass SerialQueue {\n  #tail: Promise<unknown> = Promise.resolve();\n\n  run<T>(operation: () => T | Promise<T>): Promise<T> {\n    const result = this.#tail.then(operation);\n    this.#tail = result.catch(() => {});\n    return result;\n  }\n}\n\nclass Statements {\n  readonly #db: Database;\n  readonly #cache = new Map<string, PreparedStatement>();\n\n  constructor(db: Database) {\n    this.#db = db;\n  }\n\n  bound(sql: string, params: readonly SqliteValue[]): PreparedStatement {\n    let statement = this.#cache.get(sql);\n    if (!statement) {\n      statement = this.#db.prepare(sql);\n      this.#cache.set(sql, statement);\n    }\n    statement.reset(true);\n    if (params.length > 0) statement.bind([...params]);\n    return statement;\n  }\n\n  finalize(): void {\n    for (const statement of this.#cache.values()) statement.finalize();\n    this.#cache.clear();\n  }\n}\n\nclass WasmSqliteExecutor implements SqliteExecutor {\n  protected readonly db: Database;\n  protected readonly statements: Statements;\n\n  constructor(db: Database, statements: Statements) {\n    this.db = db;\n    this.statements = statements;\n  }\n\n  async exec(sql: string): Promise<void> {\n    this.check();\n    this.db.exec(sql);\n  }\n\n  async run(sql: string, ...params: SqliteValue[]): Promise<void> {\n    this.check();\n    this.statements.bound(sql, params).stepReset();\n  }\n\n  async get<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T | undefined> {\n    this.check();\n    const statement = this.statements.bound(sql, params);\n    const row = statement.step() ? (statement.get({}) as Row as T) : undefined;\n    statement.reset();\n    return row;\n  }\n\n  async all<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T[]> {\n    this.check();\n    const statement = this.statements.bound(sql, params);\n    const rows: T[] = [];\n    while (statement.step()) rows.push(statement.get({}) as Row as T);\n    statement.reset();\n    return rows;\n  }\n\n  protected check(): void {}\n}\n\nclass WasmSqliteTransaction extends WasmSqliteExecutor {\n  active = true;\n\n  protected override check(): void {\n    if (!this.active) throw new Error('SQLite transaction handle is no longer active');\n  }\n}\n\nexport class WasmSqliteDatabase extends WasmSqliteExecutor implements SqliteDatabase {\n  readonly #queue = new SerialQueue();\n  readonly #closed: () => void;\n\n  constructor(db: Database, closed: () => void = () => {}) {\n    super(db, new Statements(db));\n    this.#closed = closed;\n  }\n\n  override exec(sql: string): Promise<void> {\n    return this.#queue.run(() => super.exec(sql));\n  }\n\n  override run(sql: string, ...params: SqliteValue[]): Promise<void> {\n    return this.#queue.run(() => super.run(sql, ...params));\n  }\n\n  override get<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T | undefined> {\n    return this.#queue.run(() => super.get<T>(sql, ...params));\n  }\n\n  override all<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T[]> {\n    return this.#queue.run(() => super.all<T>(sql, ...params));\n  }\n\n  transaction<T>(callback: (transaction: SqliteExecutor) => Promise<T>): Promise<T> {\n    return this.#queue.run(async () => {\n      const transaction = new WasmSqliteTransaction(this.db, this.statements);\n      this.db.exec('BEGIN IMMEDIATE');\n      try {\n        const result = await callback(transaction);\n        this.db.exec('COMMIT');\n        return result;\n      } catch (error) {\n        this.#rollback(error);\n        throw error;\n      } finally {\n        transaction.active = false;\n      }\n    });\n  }\n\n  close(): Promise<void> {\n    return this.#queue.run(() => {\n      try {\n        this.statements.finalize();\n        this.db.close();\n      } finally {\n        this.#closed();\n      }\n    });\n  }\n\n  #rollback(cause: unknown): void {\n    try {\n      this.db.exec('ROLLBACK');\n    } catch (error) {\n      throw new AggregateError([cause, error], 'SQLite rollback failed');\n    }\n  }\n}\n\nexport interface OpfsSqliteOptions extends PoolAccess {\n  directory?: string;\n  file?: string;\n  load?: typeof init;\n}\n\nexport const AGENT_DIRECTORY = '/.slicc/agent';\n\nexport async function openMemorySqliteStorage(): Promise<Storage> {\n  const sqlite3 = await init();\n  return SqliteStorage.open(new WasmSqliteDatabase(new sqlite3.oo1.DB(':memory:', 'c')));\n}\n\nexport async function openOpfsSqliteStorage(options: OpfsSqliteOptions = {}): Promise<Storage> {\n  const directory = options.directory ?? AGENT_DIRECTORY;\n  const release = await holdLock(\n    options.locks ?? navigator.locks,\n    `slicc-agent-sqlite:${directory}`\n  );\n  try {\n    await settlePool(directory, options);\n    const sqlite3 = await (options.load ?? init)();\n    const pool = await sqlite3.installOpfsSAHPoolVfs({ name: vfsName(directory), directory });\n    const db = new pool.OpfsSAHPoolDb(options.file ?? '/agent.sqlite');\n    db.exec('PRAGMA journal_mode = TRUNCATE');\n    return await SqliteStorage.open(new WasmSqliteDatabase(db, release));\n  } catch (error) {\n    release();\n    throw error;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/types/client.d.ts

@@ -0,0 +1,14 @@
+import { type Context, type ReplicatedState } from '@earendil-works/chord';
+import type { ConversationView } from '@earendil-works/pi-durable';
+import { AgentControl, type SendMode } from './services.ts';
+import { type PortEndpoint } from './wire.ts';
+export interface AgentConnection {
+    readonly serverId: string;
+    readonly control: AgentControl;
+    readonly transcript: ReplicatedState<ConversationView>;
+    prompt(text: string, whenBusy?: SendMode): Promise<string>;
+    close(): Promise<void>;
+}
+export declare function connectAgent(endpoint: PortEndpoint, options?: {
+    context?: Context;
+}): Promise<AgentConnection>;

package/dist/types/control.d.ts

@@ -0,0 +1,4 @@
+import { type Conversation, type Harness, type SubmissionId } from '@earendil-works/pi-durable';
+import type { AgentControl } from './services.ts';
+export declare function submissionId(value: string): SubmissionId | undefined;
+export declare function createAgentControl(harness: Harness, conversation: Conversation): AgentControl;

package/dist/types/host.d.ts

@@ -0,0 +1,13 @@
+import { type Context } from '@earendil-works/chord';
+import type { Agent } from './agent.ts';
+import { type PortEndpoint } from './wire.ts';
+export interface AgentHost {
+    readonly serverId: string;
+    readonly agent: Agent;
+    connect(endpoint: PortEndpoint): void;
+    close(): Promise<void>;
+}
+export declare function hostAgent(agent: Agent, options?: {
+    serverId?: string;
+    context?: Context;
+}): Promise<AgentHost>;

package/dist/types/index.d.ts

@@ -1,2 +1,9 @@
 export { type Agent, type AgentOptions, answerText, openAgent } from './agent.ts';
-export { type AgentClient, type AgentReply, type AgentRequest, connectAgent, type MessageEndpoint, serveAgent, } from './port.ts';
+export { type AgentConnection, connectAgent } from './client.ts';
+export { createAgentControl } from './control.ts';
+export { type AgentHost, hostAgent } from './host.ts';
+export { AGENT_LOCK, type AgentOwner, type AgentWorker, type OwnerOptions, startAgent, } from './owner.ts';
+export { AGENT_SESSION, AgentControl, AgentSessions, AgentTranscript, type OperationError, type PromptResult, type SendMode, type SendRequest, type SendResponse, } from './services.ts';
+export { AGENT_DIRECTORY, type OpfsSqliteOptions, openMemorySqliteStorage, openOpfsSqliteStorage, WasmSqliteDatabase, } from './sqlite.ts';
+export { PortChannel, type PortEndpoint, PortListener, withUnrefTimers } from './wire.ts';
+export { serveConnections, type WorkerScope } from './worker.ts';

package/dist/types/opfs-pool.d.ts

@@ -0,0 +1,9 @@
+export interface PoolAccess {
+    root?: () => Promise<FileSystemDirectoryHandle>;
+    locks?: LockManager;
+    attempts?: number;
+    delayMs?: number;
+}
+export declare function vfsName(directory: string): string;
+export declare function holdLock(locks: LockManager, name: string): Promise<() => void>;
+export declare function settlePool(directory: string, access?: PoolAccess): Promise<void>;

package/dist/types/owner.d.ts

@@ -0,0 +1,21 @@
+import { type AgentConnection } from './client.ts';
+import type { PortEndpoint } from './wire.ts';
+export declare const AGENT_LOCK = "slicc-agent";
+export interface AgentWorker {
+    postMessage(message: unknown, transfer: Transferable[]): void;
+    terminate(): void;
+}
+export interface AgentOwner {
+    connect(): Promise<AgentConnection>;
+    restart(): void;
+    release(): void;
+}
+export interface OwnerOptions {
+    worker: () => AgentWorker;
+    locks?: LockManager;
+    channel?: () => {
+        port1: PortEndpoint;
+        port2: Transferable;
+    };
+}
+export declare function startAgent(options: OwnerOptions): Promise<AgentOwner>;

package/dist/types/services.d.ts

@@ -0,0 +1,50 @@
+import { type Context, type ReplicatedState } from '@earendil-works/chord';
+import type { ConversationView } from '@earendil-works/pi-durable';
+export type SendMode = 'steer' | 'followUp' | 'reject';
+export interface SendRequest {
+    text: string;
+    whenBusy: SendMode;
+    requestId: string | null;
+}
+export interface OperationError {
+    code: string;
+    message: string;
+}
+export type SendResponse = {
+    accepted: true;
+    submissionId: string;
+    error: null;
+} | {
+    accepted: false;
+    submissionId: null;
+    error: OperationError;
+};
+export type PromptResult = {
+    status: 'done';
+    text: string;
+    reason: null;
+} | {
+    status: 'unanswered';
+    text: null;
+    reason: string;
+};
+export interface AgentControl {
+    send(request: SendRequest, context: Context): Promise<SendResponse>;
+    wait(submissionId: string, context: Context): Promise<PromptResult>;
+    withdraw(submissionId: string, context: Context): Promise<{
+        outcome: 'withdrawn' | 'already_placed' | 'not_found';
+    }>;
+    abort(context: Context): Promise<void>;
+    compact(instructions: string | null, context: Context): Promise<SendResponse>;
+}
+export declare const AgentControl: import("@earendil-works/chord").Service<AgentControl>;
+export interface AgentTranscript {
+    readonly state: ReplicatedState<ConversationView>;
+}
+export declare const AgentTranscript: import("@earendil-works/chord").Service<AgentTranscript>;
+export interface AgentSessions {
+    attach(sessionId: string, context: Context): Promise<void>;
+    detach(context: Context): Promise<void>;
+}
+export declare const AgentSessions: import("@earendil-works/chord").Service<AgentSessions>;
+export declare const AGENT_SESSION = "agent";

package/dist/types/sqlite.d.ts

@@ -0,0 +1,39 @@
+import type { Storage } from '@earendil-works/pi-durable';
+import { type SqliteDatabase, type SqliteExecutor, type SqliteValue } from '@earendil-works/pi-durable/storage/sqlite';
+import init, { type Database, type PreparedStatement } from '@sqlite.org/sqlite-wasm';
+import { type PoolAccess } from './opfs-pool.ts';
+declare class Statements {
+    #private;
+    constructor(db: Database);
+    bound(sql: string, params: readonly SqliteValue[]): PreparedStatement;
+    finalize(): void;
+}
+declare class WasmSqliteExecutor implements SqliteExecutor {
+    protected readonly db: Database;
+    protected readonly statements: Statements;
+    constructor(db: Database, statements: Statements);
+    exec(sql: string): Promise<void>;
+    run(sql: string, ...params: SqliteValue[]): Promise<void>;
+    get<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T | undefined>;
+    all<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T[]>;
+    protected check(): void;
+}
+export declare class WasmSqliteDatabase extends WasmSqliteExecutor implements SqliteDatabase {
+    #private;
+    constructor(db: Database, closed?: () => void);
+    exec(sql: string): Promise<void>;
+    run(sql: string, ...params: SqliteValue[]): Promise<void>;
+    get<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T | undefined>;
+    all<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T[]>;
+    transaction<T>(callback: (transaction: SqliteExecutor) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+export interface OpfsSqliteOptions extends PoolAccess {
+    directory?: string;
+    file?: string;
+    load?: typeof init;
+}
+export declare const AGENT_DIRECTORY = "/.slicc/agent";
+export declare function openMemorySqliteStorage(): Promise<Storage>;
+export declare function openOpfsSqliteStorage(options?: OpfsSqliteOptions): Promise<Storage>;
+export {};

package/dist/types/wire.d.ts

@@ -0,0 +1,27 @@
+import type { ByteTransportFactory } from '@earendil-works/pi-client';
+import type { ServerListener } from '@earendil-works/pi-server';
+type ByteConnectionAcceptor = Parameters<ServerListener['start']>[0];
+export interface PortEndpoint {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+    addEventListener(type: 'close' | 'messageerror' | 'error', listener: (event: Event) => void): void;
+    start?(): void;
+    close?(): void;
+}
+export declare function withUnrefTimers<T>(run: () => T, scope?: {
+    setTimeout: typeof setTimeout;
+}): T;
+export declare class PortListener implements ServerListener {
+    #private;
+    constructor(serverId: string);
+    start(accept: ByteConnectionAcceptor): Promise<void>;
+    close(): Promise<void>;
+    connect(endpoint: PortEndpoint): void;
+}
+export declare class PortChannel {
+    #private;
+    readonly hello: Promise<string>;
+    constructor(endpoint: PortEndpoint);
+    readonly transport: ByteTransportFactory;
+}
+export {};

package/dist/types/worker.d.ts

@@ -0,0 +1,5 @@
+import type { AgentHost } from './host.ts';
+export interface WorkerScope {
+    addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+}
+export declare function serveConnections(scope: WorkerScope, host: Promise<AgentHost>): void;

package/dist/wire.js

@@ -0,0 +1,164 @@
+function post(endpoint, chunk) {
+  const copy = chunk.slice();
+  endpoint.postMessage(copy, [copy.buffer]);
+}
+function unrefable(id) {
+  return {
+    unref() {
+      return this;
+    },
+    ref() {
+      return this;
+    },
+    [Symbol.toPrimitive]: () => id
+  };
+}
+function withUnrefTimers(run, scope = globalThis) {
+  const original = scope.setTimeout;
+  scope.setTimeout = ((...args) => {
+    const id = original(...args);
+    return typeof id === "number" ? unrefable(id) : id;
+  });
+  try {
+    return run();
+  } finally {
+    scope.setTimeout = original;
+  }
+}
+class PortConnection {
+  closed = false;
+  #endpoint;
+  #ended;
+  constructor(endpoint, ended) {
+    this.#endpoint = endpoint;
+    this.#ended = ended;
+  }
+  async send(chunk) {
+    if (this.closed) throw new Error("connection is closed");
+    post(this.#endpoint, chunk);
+  }
+  close(finalChunk) {
+    if (this.closed) return;
+    if (finalChunk) post(this.#endpoint, finalChunk);
+    this.closed = true;
+    this.#endpoint.postMessage({ close: true });
+    this.#endpoint.close?.();
+    this.#ended();
+  }
+  end() {
+    this.closed = true;
+    this.#ended();
+  }
+}
+class PortListener {
+  #serverId;
+  #connections = /* @__PURE__ */ new Set();
+  #accept;
+  constructor(serverId) {
+    this.#serverId = serverId;
+  }
+  async start(accept) {
+    this.#accept = accept;
+  }
+  async close() {
+    for (const connection of [...this.#connections]) connection.close();
+    this.#accept = void 0;
+  }
+  connect(endpoint) {
+    const accept = this.#accept;
+    if (!accept) throw new Error("agent host is not listening");
+    const connection = new PortConnection(endpoint, () => this.#connections.delete(connection));
+    this.#connections.add(connection);
+    const handler = withUnrefTimers(() => accept(connection));
+    endpoint.addEventListener("message", ({ data }) => {
+      if (data instanceof Uint8Array) handler.onData(data);
+      else if (data?.close) {
+        connection.end();
+        handler.onClose();
+      }
+    });
+    const failed = (event) => {
+      connection.end();
+      handler.onError(new Error(`agent port ${event.type}`));
+    };
+    endpoint.addEventListener("messageerror", failed);
+    endpoint.addEventListener("close", () => {
+      if (connection.closed) return;
+      connection.end();
+      handler.onClose();
+    });
+    endpoint.start?.();
+    endpoint.postMessage({ hello: this.#serverId });
+  }
+}
+class PortChannel {
+  hello;
+  #endpoint;
+  #queue = [];
+  #handlers;
+  #ended;
+  #greet;
+  #refuse;
+  constructor(endpoint) {
+    this.#endpoint = endpoint;
+    this.hello = new Promise((greet, refuse) => {
+      this.#greet = greet;
+      this.#refuse = refuse;
+    });
+    endpoint.addEventListener("message", ({ data }) => this.#receive(data));
+    endpoint.addEventListener(
+      "messageerror",
+      (event) => this.#end(new Error(`agent port ${event.type}`))
+    );
+    endpoint.addEventListener("error", (event) => this.#end(new Error(`agent port ${event.type}`)));
+    endpoint.addEventListener("close", () => this.#end("close"));
+    endpoint.start?.();
+  }
+  transport = (handlers) => {
+    this.#handlers = handlers;
+    for (const chunk of this.#queue.splice(0)) handlers.onData(chunk);
+    if (this.#ended) this.#deliver(this.#ended);
+    return {
+      send: async (chunk) => {
+        if (this.#ended) throw new Error("agent port is closed");
+        post(this.#endpoint, chunk);
+      },
+      close: () => {
+        if (this.#ended) return;
+        this.#ended = "close";
+        this.#refuse(new Error("agent port closed before hello"));
+        this.#endpoint.postMessage({ close: true });
+        this.#endpoint.close?.();
+      }
+    };
+  };
+  #receive(frame) {
+    if (frame instanceof Uint8Array) {
+      if (this.#handlers) this.#handlers.onData(frame);
+      else this.#queue.push(frame);
+    } else if ("hello" in frame) {
+      this.#greet(frame.hello);
+    } else {
+      this.#end("close");
+    }
+  }
+  #end(reason) {
+    if (this.#ended) return;
+    this.#ended = reason;
+    this.#refuse(reason === "close" ? new Error("agent port closed before hello") : reason);
+    this.#deliver(reason);
+  }
+  #deliver(reason) {
+    const handlers = this.#handlers;
+    if (!handlers) return;
+    this.#handlers = void 0;
+    if (reason === "close") handlers.onClose();
+    else handlers.onError(reason);
+  }
+}
+export {
+  PortChannel,
+  PortListener,
+  withUnrefTimers
+};
+//# sourceMappingURL=wire.js.map

package/dist/wire.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/wire.ts"],
+  "sourcesContent": ["import type { ByteTransportFactory, ByteTransportHandlers } from '@earendil-works/pi-client';\nimport type { ServerListener } from '@earendil-works/pi-server';\n\ntype ByteConnectionAcceptor = Parameters<ServerListener['start']>[0];\ntype ByteConnection = Parameters<ByteConnectionAcceptor>[0];\ntype ByteConnectionHandler = ReturnType<ByteConnectionAcceptor>;\n\nexport interface PortEndpoint {\n  postMessage(message: unknown, transfer?: Transferable[]): void;\n  addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;\n  addEventListener(\n    type: 'close' | 'messageerror' | 'error',\n    listener: (event: Event) => void\n  ): void;\n  start?(): void;\n  close?(): void;\n}\n\ntype Frame = { hello: string } | { close: true } | Uint8Array;\n\nfunction post(endpoint: PortEndpoint, chunk: Uint8Array): void {\n  const copy = chunk.slice();\n  endpoint.postMessage(copy, [copy.buffer]);\n}\n\nfunction unrefable(id: number): object {\n  return {\n    unref() {\n      return this;\n    },\n    ref() {\n      return this;\n    },\n    [Symbol.toPrimitive]: () => id,\n  };\n}\n\nexport function withUnrefTimers<T>(\n  run: () => T,\n  scope: { setTimeout: typeof setTimeout } = globalThis\n): T {\n  const original = scope.setTimeout;\n  scope.setTimeout = ((...args: Parameters<typeof setTimeout>) => {\n    const id: unknown = original(...args);\n    return typeof id === 'number' ? unrefable(id) : id;\n  }) as typeof setTimeout;\n  try {\n    return run();\n  } finally {\n    scope.setTimeout = original;\n  }\n}\n\nclass PortConnection implements ByteConnection {\n  closed = false;\n  readonly #endpoint: PortEndpoint;\n  readonly #ended: () => void;\n\n  constructor(endpoint: PortEndpoint, ended: () => void) {\n    this.#endpoint = endpoint;\n    this.#ended = ended;\n  }\n\n  async send(chunk: Uint8Array): Promise<void> {\n    if (this.closed) throw new Error('connection is closed');\n    post(this.#endpoint, chunk);\n  }\n\n  close(finalChunk?: Uint8Array): void {\n    if (this.closed) return;\n    if (finalChunk) post(this.#endpoint, finalChunk);\n    this.closed = true;\n    this.#endpoint.postMessage({ close: true } satisfies Frame);\n    this.#endpoint.close?.();\n    this.#ended();\n  }\n\n  end(): void {\n    this.closed = true;\n    this.#ended();\n  }\n}\n\nexport class PortListener implements ServerListener {\n  readonly #serverId: string;\n  readonly #connections = new Set<PortConnection>();\n  #accept: ByteConnectionAcceptor | undefined;\n\n  constructor(serverId: string) {\n    this.#serverId = serverId;\n  }\n\n  async start(accept: ByteConnectionAcceptor): Promise<void> {\n    this.#accept = accept;\n  }\n\n  async close(): Promise<void> {\n    for (const connection of [...this.#connections]) connection.close();\n    this.#accept = undefined;\n  }\n\n  connect(endpoint: PortEndpoint): void {\n    const accept = this.#accept;\n    if (!accept) throw new Error('agent host is not listening');\n    const connection = new PortConnection(endpoint, () => this.#connections.delete(connection));\n    this.#connections.add(connection);\n    const handler: ByteConnectionHandler = withUnrefTimers(() => accept(connection));\n    endpoint.addEventListener('message', ({ data }) => {\n      if (data instanceof Uint8Array) handler.onData(data);\n      else if ((data as { close?: boolean } | null)?.close) {\n        connection.end();\n        handler.onClose();\n      }\n    });\n    const failed = (event: Event) => {\n      connection.end();\n      handler.onError(new Error(`agent port ${event.type}`));\n    };\n    endpoint.addEventListener('messageerror', failed);\n    endpoint.addEventListener('close', () => {\n      if (connection.closed) return;\n      connection.end();\n      handler.onClose();\n    });\n    endpoint.start?.();\n    endpoint.postMessage({ hello: this.#serverId } satisfies Frame);\n  }\n}\n\nexport class PortChannel {\n  readonly hello: Promise<string>;\n  readonly #endpoint: PortEndpoint;\n  readonly #queue: Uint8Array[] = [];\n  #handlers: ByteTransportHandlers | undefined;\n  #ended: 'close' | Error | undefined;\n  #greet!: (serverId: string) => void;\n  #refuse!: (error: Error) => void;\n\n  constructor(endpoint: PortEndpoint) {\n    this.#endpoint = endpoint;\n    this.hello = new Promise((greet, refuse) => {\n      this.#greet = greet;\n      this.#refuse = refuse;\n    });\n    endpoint.addEventListener('message', ({ data }) => this.#receive(data as Frame));\n    endpoint.addEventListener('messageerror', (event) =>\n      this.#end(new Error(`agent port ${event.type}`))\n    );\n    endpoint.addEventListener('error', (event) => this.#end(new Error(`agent port ${event.type}`)));\n    endpoint.addEventListener('close', () => this.#end('close'));\n    endpoint.start?.();\n  }\n\n  readonly transport: ByteTransportFactory = (handlers) => {\n    this.#handlers = handlers;\n    for (const chunk of this.#queue.splice(0)) handlers.onData(chunk);\n    if (this.#ended) this.#deliver(this.#ended);\n    return {\n      send: async (chunk) => {\n        if (this.#ended) throw new Error('agent port is closed');\n        post(this.#endpoint, chunk);\n      },\n      close: () => {\n        if (this.#ended) return;\n        this.#ended = 'close';\n        this.#refuse(new Error('agent port closed before hello'));\n        this.#endpoint.postMessage({ close: true } satisfies Frame);\n        this.#endpoint.close?.();\n      },\n    };\n  };\n\n  #receive(frame: Frame): void {\n    if (frame instanceof Uint8Array) {\n      if (this.#handlers) this.#handlers.onData(frame);\n      else this.#queue.push(frame);\n    } else if ('hello' in frame) {\n      this.#greet(frame.hello);\n    } else {\n      this.#end('close');\n    }\n  }\n\n  #end(reason: 'close' | Error): void {\n    if (this.#ended) return;\n    this.#ended = reason;\n    this.#refuse(reason === 'close' ? new Error('agent port closed before hello') : reason);\n    this.#deliver(reason);\n  }\n\n  #deliver(reason: 'close' | Error): void {\n    const handlers = this.#handlers;\n    if (!handlers) return;\n    this.#handlers = undefined;\n    if (reason === 'close') handlers.onClose();\n    else handlers.onError(reason);\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/worker.js

@@ -0,0 +1,14 @@
+function serveConnections(scope, host) {
+  scope.addEventListener("message", ({ data }) => {
+    const port = data?.connect;
+    if (!port) return;
+    host.then(
+      (ready) => ready.connect(port),
+      () => port.close?.()
+    );
+  });
+}
+export {
+  serveConnections
+};
+//# sourceMappingURL=worker.js.map

package/dist/worker.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/worker.ts"],
+  "sourcesContent": ["import type { AgentHost } from './host.ts';\nimport type { PortEndpoint } from './wire.ts';\n\nexport interface WorkerScope {\n  addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;\n}\n\nexport function serveConnections(scope: WorkerScope, host: Promise<AgentHost>): void {\n  scope.addEventListener('message', ({ data }) => {\n    const port = (data as { connect?: PortEndpoint } | null)?.connect;\n    if (!port) return;\n    host.then(\n      (ready) => ready.connect(port),\n      () => port.close?.()\n    );\n  });\n}\n"],
+  "mappings": "AAOO,SAAS,iBAAiB,OAAoB,MAAgC;AACnF,QAAM,iBAAiB,WAAW,CAAC,EAAE,KAAK,MAAM;AAC9C,UAAM,OAAQ,MAA4C;AAC1D,QAAI,CAAC,KAAM;AACX,SAAK;AAAA,MACH,CAAC,UAAU,MAAM,QAAQ,IAAI;AAAA,MAC7B,MAAM,KAAK,QAAQ;AAAA,IACrB;AAAA,EACF,CAAC;AACH;",
+  "names": []
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-agent",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "SLICC's agent core on pi durable: an agent worker, session storage, remoting and pi extensions",
   "type": "module",
   "license": "Apache-2.0",
@@ -59,6 +59,10 @@
   "dependencies": {
     "@earendil-works/chord": "1.0.4",
     "@earendil-works/pi-ai": "1.0.4",
-    "@earendil-works/pi-durable": "1.0.4"
+    "@earendil-works/pi-client": "1.0.4",
+    "@earendil-works/pi-durable": "1.0.4",
+    "@earendil-works/pi-protocol": "1.0.4",
+    "@earendil-works/pi-server": "1.0.4",
+    "@sqlite.org/sqlite-wasm": "3.53.4-build2"
   }
 }

package/dist/port.js

@@ -1,57 +0,0 @@
-function isRequest(data) {
-  const value = data;
-  return typeof value?.id === "number" && typeof value.prompt === "string";
-}
-function reason(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function serveAgent(endpoint, agent) {
-  endpoint.addEventListener("message", ({ data }) => {
-    if (!isRequest(data)) return;
-    agent.then((ready) => ready.prompt(data.prompt)).then(
-      (text) => endpoint.postMessage({ id: data.id, text }),
-      (error) => endpoint.postMessage({ id: data.id, error: reason(error) })
-    );
-  });
-  endpoint.start?.();
-}
-function failure(event) {
-  const message = event.message;
-  return new Error(message ? `agent failed: ${message}` : `agent failed: ${event.type}`);
-}
-function connectAgent(endpoint) {
-  const pending = /* @__PURE__ */ new Map();
-  let broken;
-  let next = 0;
-  const fail = (event) => {
-    broken = failure(event);
-    for (const call of pending.values()) call.reject(broken);
-    pending.clear();
-  };
-  endpoint.addEventListener("message", ({ data }) => {
-    const reply = data;
-    const call = pending.get(reply.id);
-    if (!call) return;
-    pending.delete(reply.id);
-    if ("error" in reply) call.reject(new Error(reply.error));
-    else call.resolve(reply.text);
-  });
-  endpoint.addEventListener("error", fail);
-  endpoint.addEventListener("messageerror", fail);
-  endpoint.start?.();
-  return {
-    prompt(text) {
-      if (broken) return Promise.reject(broken);
-      const id = ++next;
-      return new Promise((resolve, reject) => {
-        pending.set(id, { resolve, reject });
-        endpoint.postMessage({ id, prompt: text });
-      });
-    }
-  };
-}
-export {
-  connectAgent,
-  serveAgent
-};
-//# sourceMappingURL=port.js.map

package/dist/port.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/port.ts"],
-  "sourcesContent": ["import type { Agent } from './agent.ts';\n\nexport interface AgentRequest {\n  id: number;\n  prompt: string;\n}\n\nexport type AgentReply = { id: number; text: string } | { id: number; error: string };\n\nexport interface MessageEndpoint {\n  postMessage(message: unknown): void;\n  addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;\n  addEventListener(type: 'error' | 'messageerror', listener: (event: Event) => void): void;\n  start?(): void;\n}\n\nfunction isRequest(data: unknown): data is AgentRequest {\n  const value = data as Partial<AgentRequest> | null;\n  return typeof value?.id === 'number' && typeof value.prompt === 'string';\n}\n\nfunction reason(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nexport function serveAgent(endpoint: MessageEndpoint, agent: Promise<Agent>): void {\n  endpoint.addEventListener('message', ({ data }) => {\n    if (!isRequest(data)) return;\n    agent\n      .then((ready) => ready.prompt(data.prompt))\n      .then(\n        (text) => endpoint.postMessage({ id: data.id, text } satisfies AgentReply),\n        (error: unknown) =>\n          endpoint.postMessage({ id: data.id, error: reason(error) } satisfies AgentReply)\n      );\n  });\n  endpoint.start?.();\n}\n\nexport interface AgentClient {\n  prompt(text: string): Promise<string>;\n}\n\nfunction failure(event: Event): Error {\n  const message = (event as ErrorEvent).message;\n  return new Error(message ? `agent failed: ${message}` : `agent failed: ${event.type}`);\n}\n\nexport function connectAgent(endpoint: MessageEndpoint): AgentClient {\n  const pending = new Map<number, { resolve(text: string): void; reject(error: Error): void }>();\n  let broken: Error | undefined;\n  let next = 0;\n  const fail = (event: Event) => {\n    broken = failure(event);\n    for (const call of pending.values()) call.reject(broken);\n    pending.clear();\n  };\n  endpoint.addEventListener('message', ({ data }) => {\n    const reply = data as AgentReply;\n    const call = pending.get(reply.id);\n    if (!call) return;\n    pending.delete(reply.id);\n    if ('error' in reply) call.reject(new Error(reply.error));\n    else call.resolve(reply.text);\n  });\n  endpoint.addEventListener('error', fail);\n  endpoint.addEventListener('messageerror', fail);\n  endpoint.start?.();\n  return {\n    prompt(text) {\n      if (broken) return Promise.reject(broken);\n      const id = ++next;\n      return new Promise((resolve, reject) => {\n        pending.set(id, { resolve, reject });\n        endpoint.postMessage({ id, prompt: text } satisfies AgentRequest);\n      });\n    },\n  };\n}\n"],
-  "mappings": "AAgBA,SAAS,UAAU,MAAqC;AACtD,QAAM,QAAQ;AACd,SAAO,OAAO,OAAO,OAAO,YAAY,OAAO,MAAM,WAAW;AAClE;AAEA,SAAS,OAAO,OAAwB;AACtC,SAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAC9D;AAEO,SAAS,WAAW,UAA2B,OAA6B;AACjF,WAAS,iBAAiB,WAAW,CAAC,EAAE,KAAK,MAAM;AACjD,QAAI,CAAC,UAAU,IAAI,EAAG;AACtB,UACG,KAAK,CAAC,UAAU,MAAM,OAAO,KAAK,MAAM,CAAC,EACzC;AAAA,MACC,CAAC,SAAS,SAAS,YAAY,EAAE,IAAI,KAAK,IAAI,KAAK,CAAsB;AAAA,MACzE,CAAC,UACC,SAAS,YAAY,EAAE,IAAI,KAAK,IAAI,OAAO,OAAO,KAAK,EAAE,CAAsB;AAAA,IACnF;AAAA,EACJ,CAAC;AACD,WAAS,QAAQ;AACnB;AAMA,SAAS,QAAQ,OAAqB;AACpC,QAAM,UAAW,MAAqB;AACtC,SAAO,IAAI,MAAM,UAAU,iBAAiB,OAAO,KAAK,iBAAiB,MAAM,IAAI,EAAE;AACvF;AAEO,SAAS,aAAa,UAAwC;AACnE,QAAM,UAAU,oBAAI,IAAyE;AAC7F,MAAI;AACJ,MAAI,OAAO;AACX,QAAM,OAAO,CAAC,UAAiB;AAC7B,aAAS,QAAQ,KAAK;AACtB,eAAW,QAAQ,QAAQ,OAAO,EAAG,MAAK,OAAO,MAAM;AACvD,YAAQ,MAAM;AAAA,EAChB;AACA,WAAS,iBAAiB,WAAW,CAAC,EAAE,KAAK,MAAM;AACjD,UAAM,QAAQ;AACd,UAAM,OAAO,QAAQ,IAAI,MAAM,EAAE;AACjC,QAAI,CAAC,KAAM;AACX,YAAQ,OAAO,MAAM,EAAE;AACvB,QAAI,WAAW,MAAO,MAAK,OAAO,IAAI,MAAM,MAAM,KAAK,CAAC;AAAA,QACnD,MAAK,QAAQ,MAAM,IAAI;AAAA,EAC9B,CAAC;AACD,WAAS,iBAAiB,SAAS,IAAI;AACvC,WAAS,iBAAiB,gBAAgB,IAAI;AAC9C,WAAS,QAAQ;AACjB,SAAO;AAAA,IACL,OAAO,MAAM;AACX,UAAI,OAAQ,QAAO,QAAQ,OAAO,MAAM;AACxC,YAAM,KAAK,EAAE;AACb,aAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,gBAAQ,IAAI,IAAI,EAAE,SAAS,OAAO,CAAC;AACnC,iBAAS,YAAY,EAAE,IAAI,QAAQ,KAAK,CAAwB;AAAA,MAClE,CAAC;AAAA,IACH;AAAA,EACF;AACF;",
-  "names": []
-}

package/dist/types/port.d.ts

@@ -1,23 +0,0 @@
-import type { Agent } from './agent.ts';
-export interface AgentRequest {
-    id: number;
-    prompt: string;
-}
-export type AgentReply = {
-    id: number;
-    text: string;
-} | {
-    id: number;
-    error: string;
-};
-export interface MessageEndpoint {
-    postMessage(message: unknown): void;
-    addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
-    addEventListener(type: 'error' | 'messageerror', listener: (event: Event) => void): void;
-    start?(): void;
-}
-export declare function serveAgent(endpoint: MessageEndpoint, agent: Promise<Agent>): void;
-export interface AgentClient {
-    prompt(text: string): Promise<string>;
-}
-export declare function connectAgent(endpoint: MessageEndpoint): AgentClient;