@nyte-ai/core 0.0.24 → 0.0.25-beta.1

package/dist/chunks/{compose-97y00axn.js → compose-rh1d2g0s.js}

@@ -9,35 +9,42 @@ import {
 import {
   createWorkspaces2,
   workspaceHandle2
-} from "./compose-917xy085.js";
+} from "./compose-pjkzf9ev.js";
 import {
   cover2,
   advance2,
   repair2
-} from "./compose-1tdb9ezw.js";
+} from "./compose-8nysak5a.js";
+import {
+  pause2,
+  resume2
+} from "./compose-wgs4rgfp.js";
 import {
   gate2,
   gated2,
   createPrincipals2
-} from "./compose-jwy1gba9.js";
+} from "./compose-7sjf0y70.js";
+import {
+  loadPlugins2
+} from "./compose-75pnchkk.js";
 import {
   createSettingsApi2
-} from "./compose-a40dnhy5.js";
+} from "./compose-vphbntyn.js";
 import {
   readWorkspaceCatalog2,
   runWorkspaceCommand2,
   completeWorkspaceCommand2
-} from "./compose-yr19b453.js";
+} from "./compose-4jqwbez4.js";
 import {
   inspect2
-} from "./compose-smsafpqe.js";
+} from "./compose-d5yhtpa7.js";
 import {
   watchHost2
 } from "./compose-xm52jghq.js";
 import {
   sessionHandle2,
   createSessions2
-} from "./compose-2gsbcjgv.js";
+} from "./compose-hf0nrd46.js";
 
 // src/api/connection.ts
 import { SdkError } from "@nyte-ai/schema";
@@ -89,7 +96,11 @@ function createConnection2(kernel, models, context) {
     ...handle,
     watch: (options) => track(handle.watch(options)),
     ...watchStore2(() => track(handle.watch())),
-    head: (name) => head(handle.head(name))
+    head: (name) => head(handle.head(name)),
+    part: (id) => {
+      const part = handle.part(id);
+      return { ...part, watch: () => track(part.watch()) };
+    }
   });
   const capability = async (kind, found) => {
     const provided = await found();
@@ -156,7 +167,7 @@ function createConnection2(kernel, models, context) {
     }),
     settings: gated2("settings", createSettingsApi2(kernel), authority),
     plugins: gated2("plugins", {
-      replace: async (plugins, scope) => kernel.plugins.replace(await kernel.plugins.load(listPluginPaths(plugins)), scope),
+      replace: (plugins, scope) => replaceFiles(kernel, plugins, scope),
       check: async (plugins) => kernel.plugins.check(await kernel.plugins.load(listPluginPaths(plugins)))
     }, authority),
     principals: gated2("principals", createPrincipals2(kernel), authority),
@@ -175,23 +186,26 @@ function createHost2(kernel, input) {
   return {
     ...connection,
     plugins: {
-      replace: async (plugins, scope) => kernel.plugins.replace(await loaded(kernel, plugins), scope),
-      check: async (plugins) => kernel.plugins.check(await loaded(kernel, plugins))
+      replace: (plugins, scope) => kernel.plugins.replace(plugins, scope),
+      check: async (plugins) => kernel.plugins.check(await loadPlugins2(kernel, plugins))
     },
     inspect: (session) => inspect2(kernel.store, session),
     execution: {
       cover: (coverage) => cover2(kernel, coverage),
       advance: (step) => advance2(kernel, step),
-      repair: (page) => repair2(kernel, page)
+      repair: (page) => repair2(kernel, page),
+      pause: () => pause2(kernel),
+      resume: () => resume2(kernel)
     }
   };
 }
+async function replaceFiles(kernel, files, scope) {
+  const paths = listPluginPaths(files);
+  await kernel.plugins.load(paths);
+  return kernel.plugins.replace(paths.map((path) => ({ path })), scope);
+}
 function listPluginPaths(files) {
   return files.map((file) => file.path);
 }
-async function loaded(kernel, plugins) {
-  const each = await Promise.all(plugins.map(async (plugin) => ("id" in plugin) ? [plugin] : kernel.plugins.load([plugin.path])));
-  return each.flat();
-}
 
 export { createConnection2, createHost2 };

package/dist/chunks/compose-s23st6q6.js

@@ -0,0 +1,4 @@
+// src/contract/session.ts
+var HOLD_MS2 = 20000;
+
+export { HOLD_MS2 };

package/dist/chunks/{compose-bbhk8vnr.js → compose-s4kyfjj6.js}

@@ -10,10 +10,10 @@ import {
   readRefExpectation2,
   put2,
   readCall2
-} from "./compose-vn7b7fdj.js";
+} from "./compose-ydth4n0z.js";
 import {
   publishSet2
-} from "./compose-ad80nkkn.js";
+} from "./compose-1kvvrw50.js";
 
 // src/fold/commit.ts
 import { SdkError } from "@nyte-ai/schema";

package/dist/chunks/{compose-t9fcqtby.js → compose-sjfbxw65.js}

@@ -27,26 +27,34 @@ import {
   readCall2,
   coveredHere2,
   guard2
-} from "./compose-vn7b7fdj.js";
+} from "./compose-ydth4n0z.js";
 import {
   traced2,
   followTrace2,
   takeReceiptTrace2
 } from "./compose-sd0stm97.js";
+import {
+  holdsReports2
+} from "./compose-nenmmq5w.js";
 import {
   commit2
-} from "./compose-bbhk8vnr.js";
+} from "./compose-s4kyfjj6.js";
 import {
   withFold2
-} from "./compose-xhtgytrh.js";
+} from "./compose-122g5jvb.js";
+import {
+  buildMessage2,
+  admitted2,
+  pendingReceipt2
+} from "./compose-2e84znn8.js";
 import {
   fence2,
   finishFence2
-} from "./compose-w6zb11k1.js";
+} from "./compose-kgdmzx0n.js";
 import {
   holdSummary2,
   summarizedMove2
-} from "./compose-tppkp915.js";
+} from "./compose-kw3bf8mf.js";
 import {
   refusalError2,
   collectContributions2
@@ -59,7 +67,7 @@ import {
   settleReceipt2,
   reserve2,
   known2
-} from "./compose-fnncnk81.js";
+} from "./compose-dywbt4he.js";
 import {
   landed2,
   chooseSendSchedule2
@@ -94,8 +102,7 @@ async function sendNow2(kernel, input) {
   const target = sending.options.replace;
   if (target === undefined)
     return admit(sending);
-  if ((await withFold2(kernel, input.session, (state) => state.inputs.get(target)))?.schedule.kind === "deciding")
-    throw new SdkError("invalid", `Message ${target} is still being decided.`);
+  await refuseDeciding(kernel, input.session, target);
   const keyed = {
     id: sending.options.id ?? asId(crypto.randomUUID()),
     digest: await hashSendRequest(sending)
@@ -104,7 +111,38 @@ async function sendNow2(kernel, input) {
   if (replayed !== null)
     return replayed;
   const inbox = await readInbox2(kernel.store, input.session, input.head);
-  return inbox.messages.includes(target) ? revise(sending, target, keyed) : edit(sending, target, keyed);
+  if (!inbox.messages.includes(target))
+    return edit(sending, target, keyed);
+  const gated = await gateRevision(sending, target);
+  return await revise(sending, target, gated, keyed) ?? editGated(sending, target, { ...keyed, ...gated });
+}
+async function reviseQueued2(kernel, input, activation = false) {
+  const { session, head, message } = input;
+  if (!activation)
+    await kernel.plugins.runtime(session).ready;
+  await refuseDeciding(kernel, session, message);
+  const sending = {
+    kernel,
+    session,
+    head,
+    context: input.context,
+    content: input.content,
+    options: input.options ?? {},
+    stop: null
+  };
+  const queued = (await readInbox2(kernel.store, session, head)).messages.includes(message);
+  if (queued && await revise(sending, message, await gateRevision(sending, message), null) !== null)
+    return { kind: "revised" };
+  return readDeparture2(kernel, session, message);
+}
+async function readDeparture2(kernel, session, message) {
+  const landed = await withFold2(kernel, session, (state) => state.inputs.get(message)?.landed ?? null);
+  return landed === null ? { kind: "missing" } : { kind: "sent" };
+}
+async function refuseDeciding(kernel, session, message) {
+  const input = await withFold2(kernel, session, (state) => state.inputs.get(message));
+  if (input?.schedule.kind === "deciding")
+    throw new SdkError("invalid", `Message ${message} is still being decided.`);
 }
 function selectRunStart2(state, head, inputs) {
   if (inputs.some((input) => input.schedule.kind === "deciding"))
@@ -113,7 +151,7 @@ function selectRunStart2(state, head, inputs) {
   if (prompt !== undefined)
     return { origin: { kind: "input", message: prompt.id }, input: prompt };
   const execution = state.heads.get(head)?.info.execution;
-  if (execution?.kind !== "idle" || execution.lastRun?.end.kind !== "completed")
+  if (execution?.kind !== "idle" || holdsReports2(execution))
     return null;
   const report = inputs.flatMap((input) => input.source.kind === "child" || input.source.kind === "job" ? [{ origin: { kind: "continuation", from: input.source.kind }, input }] : []).at(0);
   return report ?? null;
@@ -124,7 +162,10 @@ async function landing2(kernel, session, head, ids, run, start = null) {
       readTip2(kernel.store, session, head),
       readInbox2(kernel.store, session, head)
     ]);
-    const due = inbox.messages.filter((message) => ids.includes(message));
+    const held = inbox.hold?.message;
+    if (start !== null && held !== undefined && ids.includes(held))
+      return [];
+    const due = inbox.messages.filter((message) => ids.includes(message) && message !== held);
     if (due.length === 0)
       return [];
     const { inputs, siblings, starts } = await withFold2(kernel, session, (state) => ({
@@ -215,7 +256,7 @@ async function admit(sending) {
       resolve(sending, submission.configuration)
     ]);
     const landing = landed2(kernel, submission, run?.record ?? null);
-    const message = buildMessage(asId(id), landing, {
+    const message = buildMessage2(asId(id), landing, {
       schedule: await chooseSendSchedule2(landing.delivery, configuration, run?.record ?? null),
       covered,
       configuration,
@@ -223,8 +264,8 @@ async function admit(sending) {
       position: inbox.messages.length
     });
     const outcome = await commit2(kernel, [
-      await admitted(kernel, session, head, inbox, [...inbox.messages, message.id], message),
-      await pendingReceipt(kernel.store, session, id, digest, "absent")
+      await admitted2(kernel, session, head, inbox, [...inbox.messages, message.id], message),
+      await pendingReceipt2(kernel.store, session, id, digest, "absent")
     ]);
     if (outcome.kind === "stale")
       return outcome.name === receiptRef2(session, id) && await known2(kernel.store, session, id, "send", digest) ? sendReceipt2(kernel, session, id) : STALE2;
@@ -233,9 +274,8 @@ async function admit(sending) {
     return sendReceipt2(kernel, session, id);
   });
 }
-async function revise(sending, target, keyed) {
-  const { kernel, session, head, options } = sending;
-  const { id, digest } = keyed;
+async function gateRevision(sending, target) {
+  const { kernel, session, options } = sending;
   const previous = await withFold2(kernel, session, (state) => state.inputs.get(target));
   const submission = await gate(sending, target, {
     content: sending.content,
@@ -244,9 +284,17 @@ async function revise(sending, target, keyed) {
     configuration: options.configuration ?? null,
     replace: target
   });
-  const configured = async () => submission.configuration === null && previous !== undefined ? previous.configuration : resolve(sending, submission.configuration);
+  return {
+    previous,
+    submission,
+    configured: async () => submission.configuration === null && previous !== undefined ? previous.configuration : resolve(sending, submission.configuration)
+  };
+}
+async function revise(sending, target, gated, keyed) {
+  const { kernel, session, head, options } = sending;
+  const { previous, submission, configured } = gated;
   const covered = await coveredHere2(kernel, session);
-  const revised = await attempt2(`Revising ${target}`, async () => {
+  return attempt2(`Revising ${target}`, async () => {
     const [inbox, run, configuration] = await Promise.all([
       readInbox2(kernel.store, session, head),
       liveRun3(kernel.store, session, head),
@@ -258,25 +306,19 @@ async function revise(sending, target, keyed) {
     const rest = inbox.messages.filter((message) => message !== target);
     const position = findInsertionIndex(options.position, rest, current);
     const landing = landed2(kernel, submission, run?.record ?? null);
-    const message = buildMessage(target, landing, {
+    const message = buildMessage2(target, landing, {
       schedule: await chooseSendSchedule2(landing.delivery, configuration, run?.record ?? null),
       covered,
       configuration,
       replaced: previous?.replaced ?? null,
       position
     });
+    const update = await admitted2(kernel, session, head, inbox, [...rest.slice(0, position), target, ...rest.slice(position)], message);
     const outcome = await commit2(kernel, [
-      await admitted(kernel, session, head, inbox, [...rest.slice(0, position), target, ...rest.slice(position)], message),
       {
-        name: receiptRef2(session, id),
-        target: await put2(kernel.store, "receipt", {
-          id: asId(target),
-          kind: "send",
-          digest,
-          outcome: null
-        }),
-        expect: "absent",
+        ...update,
         events: [
+          ...update.events ?? [],
           {
             head,
             kind: "input",
@@ -286,16 +328,27 @@ async function revise(sending, target, keyed) {
             position
           }
         ]
-      }
+      },
+      ...keyed === null ? [] : [
+        {
+          name: receiptRef2(session, keyed.id),
+          target: await put2(kernel.store, "receipt", {
+            id: asId(target),
+            kind: "send",
+            digest: keyed.digest,
+            outcome: null
+          }),
+          expect: "absent"
+        }
+      ]
     ]);
     if (outcome.kind === "stale")
-      return outcome.name === receiptRef2(session, id) ? await readReplayReceipt(kernel, session, keyed) ?? STALE2 : STALE2;
+      return keyed !== null && outcome.name === receiptRef2(session, keyed.id) ? await readReplayReceipt(kernel, session, keyed) ?? STALE2 : STALE2;
     if (covered)
       kernel.wakes.notify(session, head);
     dev2("admission", "revised", { session, head, message: target });
     return sendReceipt2(kernel, session, asId(target));
   });
-  return revised ?? editGated(sending, target, { id, digest, submission, configured });
 }
 async function edit(sending, target, keyed) {
   const { kernel, session, options } = sending;
@@ -321,7 +374,7 @@ async function editGated(sending, target, gated) {
   const covered = await coveredHere2(kernel, session);
   const abandoned = options.abandoned;
   const running = options.running ?? "stop";
-  const message = async (stopped, position) => buildMessage(asId(id), submission, {
+  const message = async (stopped, position) => buildMessage2(asId(id), submission, {
     schedule: submission.delivery === "attach" ? { kind: "attached" } : { kind: "next-turn", reason: "idle" },
     covered,
     configuration: await configured(),
@@ -357,8 +410,8 @@ async function editGated(sending, target, gated) {
         expect: readRefExpectation2(checked.tip.ref),
         events: [{ head, kind: "head", from: checked.tip.id, to: parent, reason: "moved" }]
       },
-      await admitted(kernel, session, head, checked.inbox, [...checked.inbox.messages, record.id], record),
-      await pendingReceipt(kernel.store, session, id, digest, "absent")
+      await admitted2(kernel, session, head, checked.inbox, [...checked.inbox.messages, record.id], record),
+      await pendingReceipt2(kernel.store, session, id, digest, "absent")
     ]);
     dev2("admission", "edit", { session, head, target, outcome: outcome.kind });
     if (outcome.kind === "set")
@@ -390,7 +443,7 @@ async function editGated(sending, target, gated) {
         updates: async ({ inbox, receipt, stopped }) => {
           const record = await message(stopped, inbox.messages.length);
           return [
-            await admitted(kernel, session, head, inbox, [...inbox.messages, record.id], record),
+            await admitted2(kernel, session, head, inbox, [...inbox.messages, record.id], record),
             { name: receipt.ref.name, target: receipt.ref.target, expect: receipt.ref.revision }
           ];
         }
@@ -438,7 +491,7 @@ async function admitDeciding2(kernel, session, first) {
     position: 0
   };
   return [
-    await admitted(kernel, session, MAIN2, await readInbox2(kernel.store, session, MAIN2), [message.id], message),
+    await admitted2(kernel, session, MAIN2, await readInbox2(kernel.store, session, MAIN2), [message.id], message),
     {
       name: receiptRef2(session, id),
       target: await put2(kernel.store, "receipt", {
@@ -481,7 +534,7 @@ async function readmitDeciding2(kernel, context, session, input, stop) {
       return null;
     if (!deciding)
       return input.id;
-    const message = buildMessage(input.id, submission, {
+    const message = buildMessage2(input.id, submission, {
       schedule: await chooseSendSchedule2(submission.delivery, configuration, null),
       covered,
       configuration,
@@ -489,7 +542,7 @@ async function readmitDeciding2(kernel, context, session, input, stop) {
       position
     });
     const outcome = await commit2(kernel, [
-      await admitted(kernel, session, MAIN2, inbox, inbox.messages, message)
+      await admitted2(kernel, session, MAIN2, inbox, inbox.messages, message)
     ]);
     if (outcome.kind === "stale")
       return STALE2;
@@ -498,16 +551,6 @@ async function readmitDeciding2(kernel, context, session, input, stop) {
     return message.id;
   });
 }
-function buildMessage(id, submission, placed) {
-  return {
-    id,
-    at: Date.now(),
-    content: submission.content,
-    source: submission.source,
-    delivery: submission.delivery,
-    ...placed
-  };
-}
 async function announce(kernel, session, head, message) {
   if (message.covered)
     kernel.wakes.notify(session, head);
@@ -604,41 +647,6 @@ async function resolve(sending, patch) {
     return result;
   throw refusalError2(result);
 }
-async function admitted(kernel, session, head, inbox, messages, message) {
-  const input = message.source.kind === "user" && message.delivery !== "attach";
-  const pendingInput = [
-    ...inbox.pendingInput.filter((id) => id !== message.id),
-    ...input ? [message.id] : []
-  ];
-  return {
-    name: inboxRef2(session, head),
-    target: await put2(kernel.store, "inbox", { messages, pendingInput }),
-    expect: readRefExpectation2(inbox.ref),
-    events: [
-      {
-        head,
-        kind: "input",
-        message: message.id,
-        change: "admitted",
-        content: message.content,
-        source: message.source,
-        delivery: message.delivery,
-        schedule: message.schedule,
-        covered: message.covered,
-        configuration: message.configuration,
-        replaced: message.replaced,
-        requires: [...kernel.presence?.member.capabilities ?? []]
-      }
-    ]
-  };
-}
-async function pendingReceipt(store, session, id, digest, expect) {
-  return {
-    name: receiptRef2(session, id),
-    target: await put2(store, "receipt", { id, kind: "send", digest, outcome: null }),
-    expect
-  };
-}
 function hashSendRequest(sending) {
   const { options } = sending;
   return objectId2({
@@ -663,4 +671,4 @@ function findInsertionIndex(position, rest, current) {
   return before < 0 ? Math.min(current, rest.length) : before;
 }
 
-export { send2, sendNow2, selectRunStart2, landing2, admitDeciding2, readmitDeciding2 };
+export { send2, sendNow2, reviseQueued2, readDeparture2, selectRunStart2, landing2, admitDeciding2, readmitDeciding2 };

package/dist/chunks/{compose-a40dnhy5.js → compose-vphbntyn.js}

@@ -13,31 +13,31 @@ import {
   requireSession2,
   put2,
   attempt2
-} from "./compose-vn7b7fdj.js";
+} from "./compose-ydth4n0z.js";
 import {
   check2
 } from "./compose-bj54tkph.js";
 import {
   commit2
-} from "./compose-bbhk8vnr.js";
+} from "./compose-s4kyfjj6.js";
 import {
   WORKSPACE_TRUST2
-} from "./compose-8pp3vtv0.js";
+} from "./compose-hx8j2kef.js";
 import {
   SKILL_PATHS2,
   dropScans2
-} from "./compose-c4z4kp98.js";
+} from "./compose-j8xmyfy6.js";
 import {
   trustChanged2
-} from "./compose-917xy085.js";
+} from "./compose-pjkzf9ev.js";
 import {
   settingInfos2,
   readSettingLayers2,
   findSettingDefinition2
-} from "./compose-qwbe95qs.js";
+} from "./compose-n5f6w2y6.js";
 import {
   publishCatalog2
-} from "./compose-ae5t6v5b.js";
+} from "./compose-zq7ar8qm.js";
 
 // src/extend/settings.ts
 import { isJson, SdkError } from "@nyte-ai/schema";

package/dist/chunks/compose-vxme67gg.js

@@ -0,0 +1,63 @@
+import {
+  HOLD_MS2
+} from "./compose-s23st6q6.js";
+import {
+  inboxRef2
+} from "./compose-cqpjcx2t.js";
+import {
+  STALE2,
+  readInbox2,
+  inboxWithout2,
+  readRefExpectation2,
+  put2,
+  attempt2
+} from "./compose-ydth4n0z.js";
+import {
+  commit2
+} from "./compose-s4kyfjj6.js";
+import {
+  readDeparture2
+} from "./compose-sjfbxw65.js";
+
+// src/engine/holds.ts
+async function leaseHold2(kernel, session, head, message) {
+  const held = await attempt2(`Holding ${message}`, async () => {
+    const inbox = await readInbox2(kernel.store, session, head);
+    if (!inbox.messages.includes(message))
+      return null;
+    const outcome = await commit2(kernel, [
+      {
+        name: inboxRef2(session, head),
+        target: await put2(kernel.store, "inbox", {
+          ...inboxWithout2(inbox, []),
+          hold: { message, until: Date.now() + HOLD_MS2 }
+        }),
+        expect: readRefExpectation2(inbox.ref)
+      }
+    ]);
+    return outcome.kind === "set" ? { kind: "held" } : STALE2;
+  });
+  return held ?? readDeparture2(kernel, session, message);
+}
+async function releaseHold2(kernel, session, head, message) {
+  const released = await attempt2(`Releasing ${message}`, async () => {
+    const inbox = await readInbox2(kernel.store, session, head);
+    if (inbox.hold?.message !== message)
+      return false;
+    const outcome = await commit2(kernel, [
+      {
+        name: inboxRef2(session, head),
+        target: await put2(kernel.store, "inbox", {
+          messages: inbox.messages,
+          pendingInput: inbox.pendingInput
+        }),
+        expect: readRefExpectation2(inbox.ref)
+      }
+    ]);
+    return outcome.kind === "set" ? true : STALE2;
+  });
+  if (released)
+    kernel.wakes.notify(session, head);
+}
+
+export { leaseHold2, releaseHold2 };

package/dist/chunks/compose-wgs4rgfp.js

@@ -0,0 +1,32 @@
+// src/drive/pause.ts
+function pause2(kernel) {
+  const state = kernel.executionState;
+  if (state.paused !== null)
+    return;
+  state.paused = Promise.withResolvers();
+  state.streams.abort();
+}
+function resume2(kernel) {
+  const state = kernel.executionState;
+  const paused = state.paused;
+  if (paused === null)
+    return;
+  state.paused = null;
+  state.streams = new AbortController;
+  paused.resolve();
+}
+async function unpaused2(kernel, signal) {
+  const paused = kernel.executionState.paused;
+  if (paused === null || signal.aborted)
+    return;
+  const aborted = Promise.withResolvers();
+  const stop = () => aborted.resolve();
+  signal.addEventListener("abort", stop, { once: true });
+  try {
+    await Promise.race([paused.promise, aborted.promise]);
+  } finally {
+    signal.removeEventListener("abort", stop);
+  }
+}
+
+export { pause2, resume2, unpaused2 };