@nyte-ai/sdk 0.0.0-stage → 0.0.18

package/dist/chunks/capability-y1amted3.js

@@ -0,0 +1,230 @@
+import {
+  resolveCapability2
+} from "./capability-mr5m2wn2.js";
+import {
+  loginHandle2
+} from "./capability-nh422cp0.js";
+import {
+  receiptHandle2,
+  batchOutcome2
+} from "./capability-2q3s96kg.js";
+
+// src/workspace.ts
+import { asId, foldJobChange } from "@nyte-ai/schema";
+import { closable } from "@nyte-ai/core";
+var encoder = new TextEncoder;
+function workspaceHandle2(rows, workspace) {
+  return {
+    id: workspace,
+    info: () => rows.call("workspace.info", { workspace }),
+    watch: () => rows.watch("workspace.watch", { workspace }),
+    catalog: () => rows.call("workspace.catalog", { workspace }),
+    command: (name, text) => rows.call("workspace.command", { workspace, name, text }),
+    completeCommand: (name, prefix) => rows.call("workspace.completeCommand", { workspace, name, prefix }),
+    mcp: {
+      watch: () => rows.watch("mcp.watch", { workspace }),
+      reconnect: (server) => rows.call("mcp.reconnect", { workspace, server }),
+      setEnabled: (server, enabled) => rows.call("mcp.setEnabled", { workspace, server, enabled }),
+      login: (server) => loginHandle2(rows, async () => (await rows.call("mcp.login", { workspace, server })).login, null),
+      logout: (server) => rows.call("mcp.logout", { workspace, server }),
+      add: (server, config, scope) => rows.call("mcp.add", { workspace, server, config, scope }),
+      remove: (server, scope) => rows.call("mcp.remove", { workspace, server, scope })
+    },
+    update: (patch) => rows.call("workspace.update", { workspace, patch }),
+    reload: () => rows.call("workspace.reload", { workspace }),
+    jobs: jobsApi(rows, workspace),
+    job: (id) => jobHandle(rows, workspace, id, null),
+    changes: (run) => rows.call("workspace.changes", { workspace, run }),
+    patches: (run, paths, options) => mapped(rows.frames("workspace.patches", { workspace, run, paths, options }), patchSet),
+    files: async () => resolveCapability2(await rows.call("workspace.files", { workspace }), () => filesApi(rows, workspace)),
+    git: async () => resolveCapability2(await rows.call("workspace.git", { workspace }), () => gitApi(rows, workspace)),
+    github: async () => resolveCapability2(await rows.call("workspace.github", { workspace }), () => githubApi(rows, workspace)),
+    browser: async () => resolveCapability2(await rows.call("workspace.browser", { workspace }), () => browserApi(rows, workspace))
+  };
+}
+function filesApi(rows, workspace) {
+  const upload = (source) => rows.upload("files.upload", { workspace }, streamBytes(source));
+  const plan = (pending) => ({
+    put: (input) => plan([...pending, { kind: "put", ...input }]),
+    remove: (input) => plan([...pending, { kind: "remove", ...input }]),
+    async apply() {
+      const entries = await Promise.all(pending.map(async (entry) => {
+        if (entry.kind === "remove")
+          return entry;
+        const { contents, ...rest } = entry;
+        return {
+          ...rest,
+          contents: typeof contents === "string" || !(contents instanceof Uint8Array) ? contents : { blob: await upload(once(contents)) }
+        };
+      }));
+      const { receipt } = await rows.call("files.batch", {
+        workspace,
+        entries,
+        id: asId(crypto.randomUUID())
+      });
+      return receiptHandle2(rows, null, receipt, batchOutcome2);
+    }
+  });
+  return {
+    read: (path) => rows.call("files.read", { workspace, path }),
+    bytes: (path) => rows.bytes("files.bytes", { workspace, path }),
+    stat: (path) => rows.call("files.stat", { workspace, path }),
+    write: (path, contents, options) => rows.upload("files.write", { workspace, path, options }, typeof contents === "string" ? encoder.encode(contents) : contents),
+    remove: (path, options) => rows.call("files.remove", { workspace, path, options }),
+    batch: () => plan([]),
+    format: (path, contents) => rows.call("files.format", { workspace, path, contents }),
+    scan: (input) => rows.frames("files.scan", { workspace, ...input }),
+    find: (input) => rows.call("files.find", { workspace, ...input }),
+    search: (input) => rows.frames("files.search", { workspace, ...input }),
+    watch: (input) => rows.watch("files.watch", { workspace, ...input }),
+    upload
+  };
+}
+function githubApi(rows, workspace) {
+  return {
+    state: () => rows.call("github.state", { workspace }),
+    createPullRequest: (input) => rows.call("github.createPullRequest", { workspace, input })
+  };
+}
+function gitApi(rows, workspace) {
+  return {
+    status: () => rows.call("git.status", { workspace }),
+    watch: () => rows.watch("git.watch", { workspace }),
+    changes: (scope, options) => rows.call("git.changes", { workspace, scope, options }),
+    watchChanges: (scope, options) => rows.watch("git.watchChanges", { workspace, scope, options }),
+    patches: (scope, paths, options) => mapped(rows.frames("git.patches", { workspace, scope, paths, options }), patchSet),
+    contents: (path, scope) => rows.call("git.contents", { workspace, path, scope }),
+    log: (input) => rows.call("git.log", { workspace, ...input }),
+    refs: () => rows.call("git.refs", { workspace }),
+    blame: (path) => rows.call("git.blame", { workspace, path }),
+    stage: (paths, options) => rows.call("git.stage", { workspace, paths, options }),
+    unstage: (paths, options) => rows.call("git.unstage", { workspace, paths, options }),
+    discard: (paths, options) => rows.call("git.discard", { workspace, paths, options }),
+    commit: (input, options) => rows.call("git.commit", { workspace, input, options }),
+    branch: (input, options) => rows.call("git.branch", { workspace, input, options }),
+    push: (input, options) => rows.call("git.push", { workspace, input, options })
+  };
+}
+function browserApi(rows, workspace) {
+  return {
+    open: async ({ url }) => pageHandle(rows, workspace, (await rows.call("browser.open", { workspace, url, id: crypto.randomUUID() })).id),
+    adopt: async (id) => pageHandle(rows, workspace, (await rows.call("browser.adopt", { workspace, id })).id),
+    list: () => rows.call("browser.list", { workspace }),
+    watch: () => rows.watch("browser.watch", { workspace })
+  };
+}
+function pageHandle(rows, workspace, page) {
+  const close = async () => {
+    await rows.call("page.close", { workspace, page });
+  };
+  return {
+    id: page,
+    view: () => rows.call("page.view", { workspace, page }),
+    watch: () => rows.watch("page.watch", { workspace, page }),
+    snapshot: (input) => rows.call("page.snapshot", { workspace, page, ...input }),
+    navigate: (url) => rows.call("page.navigate", { workspace, page, url }),
+    back: () => rows.call("page.back", { workspace, page }),
+    forward: () => rows.call("page.forward", { workspace, page }),
+    reload: () => rows.call("page.reload", { workspace, page }),
+    stopLoading: () => rows.call("page.stopLoading", { workspace, page }),
+    click: (input) => rows.call("page.click", { workspace, page, ...input }),
+    type: (input) => rows.call("page.type", { workspace, page, ...input }),
+    press: (input) => rows.call("page.press", { workspace, page, ...input }),
+    scroll: (input) => rows.call("page.scroll", { workspace, page, ...input }),
+    wait: (condition) => rows.call("page.wait", { workspace, page, condition }),
+    console: (input) => rows.call("page.console", { workspace, page, ...input }),
+    capture: () => rows.bytes("page.capture", { workspace, page }),
+    evaluate: (expression, options) => rows.call("page.evaluate", { workspace, page, expression, options }),
+    close,
+    [Symbol.asyncDispose]: close
+  };
+}
+function jobsApi(rows, workspace) {
+  return {
+    async start(input) {
+      const view = await rows.call("jobs.start", { workspace, ...input });
+      return jobHandle(rows, workspace, view.id, view.key);
+    },
+    async recover(key) {
+      const recovered = await rows.call("jobs.recover", { workspace, key });
+      return "id" in recovered ? jobHandle(rows, workspace, recovered.id, recovered.key) : recovered;
+    },
+    list: () => rows.call("jobs.list", { workspace }),
+    watch: () => foldJobs(rows.watch("jobs.watch", { workspace }))
+  };
+}
+async function* foldJobs(changes) {
+  let jobs = [];
+  for await (const change of changes) {
+    jobs = foldJobChange(jobs, change);
+    yield jobs;
+  }
+}
+function jobHandle(rows, workspace, job, key) {
+  const readers = new Set;
+  const close = async () => {
+    await Promise.all([...readers].map((detach) => detach()));
+  };
+  return {
+    id: job,
+    key,
+    async write(bytes) {
+      await rows.upload("job.write", { workspace, job }, bytes);
+    },
+    output: () => closable(() => {
+      const frames = rows.output({ workspace, job })[Symbol.asyncIterator]();
+      const detach = async () => {
+        readers.delete(detach);
+        await frames.return?.();
+      };
+      readers.add(detach);
+      return { pull: () => frames.next(), close: detach };
+    }),
+    resize: (size) => rows.call("job.resize", { workspace, job, size }),
+    idle: () => rows.call("job.idle", { workspace, job }),
+    stop: () => rows.call("job.stop", { workspace, job }),
+    settled: (options) => rows.wait("job.settled", { workspace, job }, options),
+    close,
+    [Symbol.asyncDispose]: close
+  };
+}
+function patchSet(wire) {
+  return { revision: wire.revision, entries: new Map(Object.entries(wire.entries)) };
+}
+function mapped(source, map) {
+  return {
+    [Symbol.asyncIterator]() {
+      const iterator = source[Symbol.asyncIterator]();
+      return {
+        async next() {
+          const next = await iterator.next();
+          return next.done === true ? { done: true, value: undefined } : { done: false, value: map(next.value) };
+        },
+        async return() {
+          await iterator.return?.();
+          return { done: true, value: undefined };
+        }
+      };
+    }
+  };
+}
+function streamBytes(source) {
+  const iterator = source[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      const next = await iterator.next();
+      if (next.done === true)
+        controller.close();
+      else
+        controller.enqueue(next.value);
+    },
+    async cancel() {
+      await iterator.return?.();
+    }
+  });
+}
+async function* once(bytes) {
+  yield bytes;
+}
+
+export { workspaceHandle2 };

package/dist/src/capability.d.ts

@@ -0,0 +1,2 @@
+import type { Capability, CapabilityWire } from "@nyte-ai/schema";
+export declare function resolveCapability<T>(wire: CapabilityWire, bind: () => T): Capability<T>;

package/dist/src/capability.js

@@ -0,0 +1,6 @@
+import {
+  resolveCapability2
+} from "../chunks/capability-mr5m2wn2.js";
+export {
+  resolveCapability2 as resolveCapability
+};

package/dist/src/client.d.ts

@@ -0,0 +1,14 @@
+import type { CredentialSource, HostId, JournalEntry, Json, PrincipalId } from "@nyte-ai/schema";
+import type { Connection, RequestJournal } from "@nyte-ai/core";
+import type { Transport } from "@nyte-ai/protocol";
+type ClientContext = {
+    readonly hostId: HostId;
+    readonly principal: PrincipalId;
+    readonly credential: CredentialSource;
+    readonly journal: RequestJournal;
+    readonly journaled: readonly JournalEntry[];
+    /** The `connection.watch` that connecting read the host's first view from, left open for the first host watch to continue. */
+    readonly hostFrames?: AsyncIterator<Json>;
+};
+export declare function createClient(transport: Transport, context: ClientContext): Connection;
+export {};

package/dist/src/client.js

@@ -0,0 +1,14 @@
+import {
+  createClient2
+} from "../chunks/capability-cdz2rz6h.js";
+import"../chunks/capability-9747w1b1.js";
+import"../chunks/capability-y1amted3.js";
+import"../chunks/capability-nh422cp0.js";
+import"../chunks/capability-2q3s96kg.js";
+import"../chunks/capability-mr5m2wn2.js";
+import"../chunks/capability-8hmez9nw.js";
+import"../chunks/capability-2wk9ktc5.js";
+import"../chunks/capability-artgq59v.js";
+export {
+  createClient2 as createClient
+};

package/dist/src/connect.d.ts

@@ -0,0 +1,2 @@
+import type { ConnectOptions, Connection } from "@nyte-ai/core";
+export declare function connect(options: ConnectOptions): Promise<Connection>;

package/dist/src/connect.js

@@ -0,0 +1,15 @@
+import {
+  connect2
+} from "../chunks/capability-591c8vr1.js";
+import"../chunks/capability-cdz2rz6h.js";
+import"../chunks/capability-9747w1b1.js";
+import"../chunks/capability-y1amted3.js";
+import"../chunks/capability-nh422cp0.js";
+import"../chunks/capability-2q3s96kg.js";
+import"../chunks/capability-mr5m2wn2.js";
+import"../chunks/capability-8hmez9nw.js";
+import"../chunks/capability-2wk9ktc5.js";
+import"../chunks/capability-artgq59v.js";
+export {
+  connect2 as connect
+};

package/dist/src/history.d.ts

@@ -0,0 +1,14 @@
+import type { SessionView, ViewOptions } from "@nyte-ai/schema";
+import type { Head } from "@nyte-ai/core";
+/** A head's views with its older messages paged in on demand: each view's `messages` are the pages `earlier` loaded, then the messages the watch carries, and its `turns` the pages' turns before the watch's. Iterate it once. */
+export interface PagedViews extends AsyncIterable<SessionView> {
+    /** Loads up to `limit` messages before the oldest one shown into the views, and resolves how many came: 0 once the head's first message is shown. A call while one loads waits for that one. */
+    earlier(limit: number): Promise<number>;
+}
+/**
+ * Returns `head`'s views, older messages paged in through `head.history`. A
+ * view keeps every message shown before its own first one, so messages that
+ * leave the watch's window stay; a view whose first message was never shown
+ * (the head moved, or the window jumped past the pages) drops the pages.
+ */
+export declare function pagedViews(head: Head, options?: ViewOptions): PagedViews;

package/dist/src/history.js

@@ -0,0 +1,7 @@
+import {
+  pagedViews2
+} from "../chunks/capability-3qe1hz8t.js";
+import"../chunks/capability-8hmez9nw.js";
+export {
+  pagedViews2 as pagedViews
+};

package/dist/src/index.client.d.ts

@@ -0,0 +1,10 @@
+import { connect } from "./connect.ts";
+export { createSendJournal } from "./journal.ts";
+export * from "./surface.ts";
+/**
+ * The SDK for a client of a host in another process: `connect` without `open`, so
+ * importing it never loads the host, its models or its store.
+ */
+export declare const sdk: {
+    connect: typeof connect;
+};

package/dist/src/index.client.js

@@ -0,0 +1,57 @@
+import"../chunks/capability-8hmez9nw.js";
+import"../chunks/capability-artgq59v.js";
+import {
+  createSendJournal2
+} from "../chunks/capability-2wk9ktc5.js";
+import"../chunks/capability-9747w1b1.js";
+import"../chunks/capability-2q3s96kg.js";
+import"../chunks/capability-nh422cp0.js";
+import"../chunks/capability-mr5m2wn2.js";
+import"../chunks/capability-y1amted3.js";
+import"../chunks/capability-cdz2rz6h.js";
+import {
+  connect2
+} from "../chunks/capability-591c8vr1.js";
+import {
+  pagedViews2
+} from "../chunks/capability-3qe1hz8t.js";
+import {
+  tracePaints2
+} from "../chunks/capability-esdwn315.js";
+import {
+  dev2,
+  watchStore2,
+  clearSpans2,
+  enableTracing2,
+  followTrace2,
+  followedTrace2,
+  readSpans2,
+  SPAN_NAMES2,
+  startSpan2,
+  traced2,
+  tracing2,
+  SdkError2,
+  operationsDigest2
+} from "../chunks/capability-b52hty54.js";
+
+// src/index.client.ts
+var sdk = { connect: connect2 };
+export {
+  SPAN_NAMES2 as SPAN_NAMES,
+  SdkError2 as SdkError,
+  clearSpans2 as clearSpans,
+  createSendJournal2 as createSendJournal,
+  dev2 as dev,
+  enableTracing2 as enableTracing,
+  followTrace2 as followTrace,
+  followedTrace2 as followedTrace,
+  operationsDigest2 as operationsDigest,
+  pagedViews2 as pagedViews,
+  readSpans2 as readSpans,
+  sdk,
+  startSpan2 as startSpan,
+  tracePaints2 as tracePaints,
+  traced2 as traced,
+  tracing2 as tracing,
+  watchStore2 as watchStore
+};

package/dist/src/index.d.ts

@@ -0,0 +1,9 @@
+import { openHost } from "@nyte-ai/host";
+import { connect } from "./connect.ts";
+export type { OpenHostOptions } from "@nyte-ai/host";
+export { createSendJournal } from "./journal.ts";
+export * from "./surface.ts";
+export declare const sdk: {
+    open: typeof openHost;
+    connect: typeof connect;
+};

package/dist/src/index.js

@@ -0,0 +1,58 @@
+import"../chunks/capability-8hmez9nw.js";
+import"../chunks/capability-artgq59v.js";
+import {
+  createSendJournal2
+} from "../chunks/capability-2wk9ktc5.js";
+import"../chunks/capability-9747w1b1.js";
+import"../chunks/capability-2q3s96kg.js";
+import"../chunks/capability-nh422cp0.js";
+import"../chunks/capability-mr5m2wn2.js";
+import"../chunks/capability-y1amted3.js";
+import"../chunks/capability-cdz2rz6h.js";
+import {
+  connect2
+} from "../chunks/capability-591c8vr1.js";
+import {
+  pagedViews2
+} from "../chunks/capability-3qe1hz8t.js";
+import {
+  tracePaints2
+} from "../chunks/capability-esdwn315.js";
+import {
+  dev2,
+  watchStore2,
+  clearSpans2,
+  enableTracing2,
+  followTrace2,
+  followedTrace2,
+  readSpans2,
+  SPAN_NAMES2,
+  startSpan2,
+  traced2,
+  tracing2,
+  SdkError2,
+  operationsDigest2
+} from "../chunks/capability-b52hty54.js";
+
+// src/index.ts
+import { openHost } from "@nyte-ai/host";
+var sdk = { open: openHost, connect: connect2 };
+export {
+  SPAN_NAMES2 as SPAN_NAMES,
+  SdkError2 as SdkError,
+  clearSpans2 as clearSpans,
+  createSendJournal2 as createSendJournal,
+  dev2 as dev,
+  enableTracing2 as enableTracing,
+  followTrace2 as followTrace,
+  followedTrace2 as followedTrace,
+  operationsDigest2 as operationsDigest,
+  pagedViews2 as pagedViews,
+  readSpans2 as readSpans,
+  sdk,
+  startSpan2 as startSpan,
+  tracePaints2 as tracePaints,
+  traced2 as traced,
+  tracing2 as tracing,
+  watchStore2 as watchStore
+};

package/dist/src/index.web.d.ts

@@ -0,0 +1,8 @@
+import type { Host, OpenOptions } from "@nyte-ai/core";
+import { connect } from "./connect.ts";
+export { createSendJournal } from "./journal.ts";
+export * from "./surface.ts";
+export declare const sdk: {
+    open: (_options: OpenOptions) => Promise<Host>;
+    connect: typeof connect;
+};

package/dist/src/index.web.js

@@ -0,0 +1,63 @@
+import"../chunks/capability-8hmez9nw.js";
+import"../chunks/capability-artgq59v.js";
+import {
+  createSendJournal2
+} from "../chunks/capability-2wk9ktc5.js";
+import"../chunks/capability-9747w1b1.js";
+import"../chunks/capability-2q3s96kg.js";
+import"../chunks/capability-nh422cp0.js";
+import"../chunks/capability-mr5m2wn2.js";
+import"../chunks/capability-y1amted3.js";
+import"../chunks/capability-cdz2rz6h.js";
+import {
+  connect2
+} from "../chunks/capability-591c8vr1.js";
+import {
+  pagedViews2
+} from "../chunks/capability-3qe1hz8t.js";
+import {
+  tracePaints2
+} from "../chunks/capability-esdwn315.js";
+import {
+  dev2,
+  watchStore2,
+  clearSpans2,
+  enableTracing2,
+  followTrace2,
+  followedTrace2,
+  readSpans2,
+  SPAN_NAMES2,
+  startSpan2,
+  traced2,
+  tracing2,
+  SdkError2,
+  operationsDigest2
+} from "../chunks/capability-b52hty54.js";
+
+// src/index.web.ts
+import { SdkError } from "@nyte-ai/schema";
+var sdk = {
+  open: async (_options) => {
+    throw new SdkError("unavailable", "open needs a Node host.");
+  },
+  connect: connect2
+};
+export {
+  SPAN_NAMES2 as SPAN_NAMES,
+  SdkError2 as SdkError,
+  clearSpans2 as clearSpans,
+  createSendJournal2 as createSendJournal,
+  dev2 as dev,
+  enableTracing2 as enableTracing,
+  followTrace2 as followTrace,
+  followedTrace2 as followedTrace,
+  operationsDigest2 as operationsDigest,
+  pagedViews2 as pagedViews,
+  readSpans2 as readSpans,
+  sdk,
+  startSpan2 as startSpan,
+  tracePaints2 as tracePaints,
+  traced2 as traced,
+  tracing2 as tracing,
+  watchStore2 as watchStore
+};

package/dist/src/journal.d.ts

@@ -0,0 +1,15 @@
+import type { Disposer, HeadName, JournalEntry, Message, SessionId, SessionView } from "@nyte-ai/schema";
+import type { RequestJournal } from "@nyte-ai/core";
+import type { OperationOutput } from "@nyte-ai/protocol";
+import type { Rows } from "./rows.ts";
+export interface JournalLoop {
+    send(entry: JournalEntry): Promise<Sent>;
+    replay(entries: readonly JournalEntry[]): void;
+    unsent(session: SessionId, head: HeadName): readonly Message[];
+    landed(session: SessionId, head: HeadName, view: SessionView): void;
+    subscribe(listener: () => void): Disposer;
+}
+type Sent = OperationOutput<"head.send">;
+export declare function createSendJournal(): RequestJournal;
+export declare function journalLoop(rows: Rows, journal: RequestJournal): JournalLoop;
+export {};

package/dist/src/journal.js

@@ -0,0 +1,9 @@
+import {
+  createSendJournal2,
+  journalLoop2
+} from "../chunks/capability-2wk9ktc5.js";
+import"../chunks/capability-artgq59v.js";
+export {
+  createSendJournal2 as createSendJournal,
+  journalLoop2 as journalLoop
+};

package/dist/src/login.d.ts

@@ -0,0 +1,8 @@
+import type { Login } from "@nyte-ai/core";
+import type { Rows } from "./rows.ts";
+/**
+ * A login streamed over `login.steps`: `begin` starts it on the host and
+ * answers the key its steps and answers go by; `known` is that key when the
+ * caller knows it before starting.
+ */
+export declare function loginHandle(rows: Rows, begin: () => Promise<string>, known: string | null): Login;

package/dist/src/login.js

@@ -0,0 +1,6 @@
+import {
+  loginHandle2
+} from "../chunks/capability-nh422cp0.js";
+export {
+  loginHandle2 as loginHandle
+};

package/dist/src/paint-spans.d.ts

@@ -0,0 +1,11 @@
+import type { SessionId, SessionView } from "@nyte-ai/schema";
+/**
+ * Returns `views`, each message that arrives after the first view timed as a
+ * `client.paint` span from the view that brought it until `painted` resolves:
+ * the client's next painted frame. The first view's message that is the
+ * submit the session follows, a chat's first message started by this client,
+ * is timed too. A user message is its own submit's trace (its id is the
+ * receipt id); a part joins the submit the session last followed. With
+ * tracing off when called, returns `views` as they are.
+ */
+export declare function tracePaints(views: AsyncIterable<SessionView>, session: SessionId, painted: () => Promise<void>): AsyncIterable<SessionView>;

package/dist/src/paint-spans.js

@@ -0,0 +1,6 @@
+import {
+  tracePaints2
+} from "../chunks/capability-esdwn315.js";
+export {
+  tracePaints2 as tracePaints
+};

package/dist/src/part.d.ts

@@ -0,0 +1,4 @@
+import type { PartId, SessionId } from "@nyte-ai/schema";
+import type { Part, PartDefinition } from "@nyte-ai/core";
+import type { Rows } from "./rows.ts";
+export declare function partHandle<K extends PartDefinition>(rows: Rows, session: SessionId, id: PartId, kind: K | null): Part<K>;

package/dist/src/part.js

@@ -0,0 +1,6 @@
+import {
+  partHandle2
+} from "../chunks/capability-9747w1b1.js";
+export {
+  partHandle2 as partHandle
+};

package/dist/src/receipts.d.ts

@@ -0,0 +1,9 @@
+import type { BatchOutcome, Json, MessageId, MoveOutcome, ReceiptId, RunId, Schema, SessionId } from "@nyte-ai/schema";
+import type { Receipt, Run, SendReceipt } from "@nyte-ai/core";
+import type { Rows } from "./rows.ts";
+export declare function receiptHandle<O>(rows: Rows, session: SessionId | null, id: ReceiptId, outcome: (value: Json) => O): Receipt<O>;
+export declare function sendReceipt(rows: Rows, session: SessionId, id: ReceiptId, message: MessageId): SendReceipt;
+export declare function runHandle(rows: Rows, session: SessionId, id: RunId): Run;
+export declare function moveOutcome(value: Json): MoveOutcome;
+export declare function batchOutcome(value: Json): BatchOutcome;
+export declare function parsed<T>(schema: Schema<T>, value: unknown): T | null;

package/dist/src/receipts.js

@@ -0,0 +1,16 @@
+import {
+  receiptHandle2,
+  sendReceipt2,
+  runHandle2,
+  moveOutcome2,
+  batchOutcome2,
+  parsed2
+} from "../chunks/capability-2q3s96kg.js";
+export {
+  batchOutcome2 as batchOutcome,
+  moveOutcome2 as moveOutcome,
+  parsed2 as parsed,
+  receiptHandle2 as receiptHandle,
+  runHandle2 as runHandle,
+  sendReceipt2 as sendReceipt
+};