@lamplitisles/dsh-nanocodex 0.1.0-beta.0

package/vendor/nanocodex/browser/index.d.mts

@@ -0,0 +1,92 @@
+export * as Actions from "../actions/index.mjs";
+export {
+  createMemoryChatGptSubscriptionStore,
+  subscriptionRevision,
+} from "../runtime/subscription-store.mjs";
+export { createQuickJsEvaluator } from "../runtime/quickjs-evaluator.mjs";
+export {
+  createTempoProvider,
+  createTempoProviderFromAccounts,
+  DEFAULT_MERCATOR_MCP_URL,
+} from "../runtime/tempo-provider.mjs";
+export type {
+  AccountsTempoProviderOptions,
+  AccountsWallet,
+  TempoProvider,
+} from "../runtime/tempo-provider.mjs";
+export type {
+  AgentEvent,
+  AgentLifecycle,
+  AgentSessionContext,
+  CompactionInstructionContext,
+  CompactionInstructionResolver,
+  CompactionItemIdentity,
+  CompactionOutcome,
+  CompactionReplacedEventPayload,
+  ChatGptCredential,
+  ChatGptCredentialSeed,
+  ChatGptLoginStatus,
+  ChatGptSubscriptionHandle,
+  ChatGptSubscriptionOptions,
+  ChatGptSubscriptionStore,
+  CostStatus,
+  CodeEvaluator,
+  CodeEvaluatorEnvironment,
+  EstimatedUsdCost,
+  ExecutionEnvironment,
+  HistoryContentItem,
+  HistoryItem,
+  HistorySeed,
+  PromptInput,
+  PromptItem,
+  LifecycleTurn,
+  LifecycleTurnResult,
+  ReasoningMode,
+  SessionSnapshot,
+  Thinking,
+  CustomToolFormat,
+  Tool,
+  NamedTool,
+  ToolDefinition,
+  ToolJson,
+  ToolContext,
+  SubagentToolContext,
+  ToolConfiguration,
+  ToolMap,
+  Turn,
+  TurnResult,
+  TurnUsage,
+  McpPayment,
+  McpServer,
+  McpServers,
+  MemoryChatGptSubscriptionStore,
+  MppSession,
+  SubscriptionCommitRequest,
+  SubscriptionCommitResult,
+  SubscriptionRevision,
+  SubscriptionStoredValue,
+} from "../types.mjs";
+export * as Agent from "./Agent.mjs";
+export * as ChatGptSubscription from "./ChatGptSubscription.mjs";
+export * as Subagents from "../runtime/subagents.mjs";
+export * as Transport from "./Transport.mjs";
+export * as Voice from "./Voice.mjs";
+export * as Workspace from "./workspace.mjs";
+export * as Tools from "../tools/index.mjs";
+export {
+  createConfig,
+  type AgentParameters,
+  type AgentSnapshot,
+  type AgentStatus,
+  type Config,
+  type CreateConfigParameters,
+} from "./config.mjs";
+export {
+  defaultHostManagedWebSocketUrl,
+  openHostManagedWebSocket,
+  type HostManagedWebSocketOptions,
+} from "./hostManagedWebSocket.mjs";
+export type {
+  BrowserWebSocketConnection,
+  BrowserWebSocketRequest,
+} from "./host.mjs";

package/vendor/nanocodex/browser/index.mjs

@@ -0,0 +1,23 @@
+export * as Actions from "../actions/index.mjs";
+export {
+  createMemoryChatGptSubscriptionStore,
+  subscriptionRevision,
+} from "../runtime/subscription-store.mjs";
+export { createQuickJsEvaluator } from "../runtime/quickjs-evaluator.mjs";
+export {
+  createTempoProvider,
+  createTempoProviderFromAccounts,
+  DEFAULT_MERCATOR_MCP_URL,
+} from "../runtime/tempo-provider.mjs";
+export * as Agent from "./Agent.mjs";
+export * as ChatGptSubscription from "./ChatGptSubscription.mjs";
+export * as Subagents from "../runtime/subagents.mjs";
+export * as Transport from "./Transport.mjs";
+export * as Voice from "./Voice.mjs";
+export * as Workspace from "./workspace.mjs";
+export * as Tools from "../tools/index.mjs";
+export { createConfig } from "./config.mjs";
+export {
+  defaultHostManagedWebSocketUrl,
+  openHostManagedWebSocket,
+} from "./hostManagedWebSocket.mjs";

package/vendor/nanocodex/browser/indexeddb-durability-store.mjs

@@ -0,0 +1,197 @@
+import { durabilityRevision } from "../runtime/durability-store.mjs";
+
+const DATABASE_NAME = "nanocodex-browser-durability-v2";
+const DATABASE_VERSION = 1;
+const OWNERS = "owners";
+const STATES = "states";
+const MAX_REVISION = "18446744073709551615";
+
+/** Creates the Worker-local IndexedDB durability capability. */
+export function createIndexedDbDurabilityStore(options = {}) {
+  const indexedDb = options.indexedDB ?? globalThis.indexedDB;
+  if (!indexedDb || typeof indexedDb.open !== "function") {
+    throw new TypeError("browser durability requires IndexedDB");
+  }
+  const databaseName = options.databaseName ?? DATABASE_NAME;
+  requireId(databaseName, "browser durability database name");
+  let database;
+  const open = () => {
+    if (database) return database;
+    const opening = openDatabase(indexedDb, databaseName, () => {
+      if (database === opening) database = undefined;
+    }).catch((error) => {
+      if (database === opening) database = undefined;
+      throw error;
+    });
+    database = opening;
+    return opening;
+  };
+
+  return Object.freeze({
+    async load(stateId) {
+      requireId(stateId, "durability state ID");
+      const db = await open();
+      const transaction = db.transaction([STATES], "readonly");
+      const state = await requestResult(transaction.objectStore(STATES).get(stateId));
+      await transactionCompletion(transaction);
+      return storedState(state, stateId);
+    },
+
+    async acquire(stateId, request) {
+      requireId(stateId, "durability state ID");
+      const ownerId = requireId(request?.ownerId, "durability owner ID");
+      const db = await open();
+      const transaction = db.transaction([OWNERS, STATES], "readwrite");
+      const completed = transactionCompletion(transaction);
+      try {
+        const owners = transaction.objectStore(OWNERS);
+        const previous = await requestResult(owners.get(stateId));
+        const previousFence = previous === undefined ? "0" : storedOwner(previous, stateId).fence;
+        if (previousFence === MAX_REVISION) throw new RangeError("IndexedDB durability fence overflow");
+        const fence = durabilityRevision(BigInt(previousFence) + 1n);
+        await requestResult(owners.put({ stateId, ownerId, fence }));
+        const state = storedState(await requestResult(transaction.objectStore(STATES).get(stateId)), stateId);
+        await completed;
+        return Object.freeze({ ownerId, fence, ...state });
+      } catch (error) {
+        try { transaction.abort(); } catch {}
+        await completed.catch(() => {});
+        throw error;
+      }
+    },
+
+    async replace(stateId, request) {
+      requireId(stateId, "durability state ID");
+      const ownerId = requireId(request?.ownerId, "durability owner ID");
+      const fence = durabilityRevision(request?.fence);
+      const db = await open();
+      const transaction = db.transaction([OWNERS, STATES], "readwrite");
+      const completed = transactionCompletion(transaction);
+      try {
+        const ownerValue = await requestResult(transaction.objectStore(OWNERS).get(stateId));
+        const owner = ownerValue === undefined ? undefined : storedOwner(ownerValue, stateId);
+        if (owner?.ownerId !== ownerId || durabilityRevision(owner?.fence ?? "0") !== fence) {
+          await completed;
+          return { status: "fenced" };
+        }
+        const expectedRevision = durabilityRevision(request?.expectedRevision);
+        const states = transaction.objectStore(STATES);
+        const state = storedState(await requestResult(states.get(stateId)), stateId);
+        if (state.revision !== expectedRevision) {
+          await completed;
+          return { status: "conflict", actualRevision: state.revision };
+        }
+        if (expectedRevision === MAX_REVISION) {
+          await completed;
+          return { status: "not_committed", message: "IndexedDB durability revision overflow" };
+        }
+        const payload = requirePayload(request?.payload);
+        const revision = durabilityRevision(BigInt(expectedRevision) + 1n);
+        await requestResult(states.put({ stateId, revision, payload }));
+        await completed;
+        return { status: "replaced", revision };
+      } catch (error) {
+        try { transaction.abort(); } catch {}
+        await completed.catch(() => {});
+        throw error;
+      }
+    },
+  });
+}
+
+function openDatabase(indexedDb, databaseName, invalidate) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const request = indexedDb.open(databaseName, DATABASE_VERSION);
+    request.onupgradeneeded = () => {
+      const database = request.result;
+      database.createObjectStore(OWNERS, { keyPath: "stateId" });
+      database.createObjectStore(STATES, { keyPath: "stateId" });
+    };
+    request.onerror = () => settle(reject, request.error ?? new Error("opening browser durability failed"));
+    request.onblocked = () => settle(reject, new Error("opening browser durability was blocked"));
+    request.onsuccess = () => {
+      const opened = request.result;
+      if (settled) return opened.close();
+      const stores = Array.from(opened.objectStoreNames).sort();
+      if (stores.length !== 2 || stores[0] !== OWNERS || stores[1] !== STATES
+        || !validStoreSchema(opened, OWNERS) || !validStoreSchema(opened, STATES)) {
+        opened.close();
+        return settle(reject, new Error("incompatible IndexedDB durability schema; delete the database"));
+      }
+      settled = true;
+      opened.onversionchange = () => { invalidate(); opened.close(); };
+      opened.onclose = () => invalidate();
+      resolve(opened);
+    };
+    function settle(callback, value) {
+      if (settled) return;
+      settled = true;
+      callback(value);
+    }
+  });
+}
+
+function validStoreSchema(database, name) {
+  try {
+    const store = database.transaction([name], "readonly").objectStore(name);
+    return store.keyPath === "stateId" && store.autoIncrement === false;
+  } catch {
+    return false;
+  }
+}
+
+function storedState(value, stateId) {
+  if (value === undefined) return Object.freeze({ revision: "0", payload: null });
+  exactRecord(value, ["stateId", "revision", "payload"], "IndexedDB durability state");
+  if (value.stateId !== stateId) throw new TypeError("IndexedDB durability state ID mismatch");
+  return Object.freeze({
+    revision: durabilityRevision(value.revision),
+    payload: requirePayload(value.payload),
+  });
+}
+
+function storedOwner(value, stateId) {
+  exactRecord(value, ["stateId", "ownerId", "fence"], "IndexedDB durability owner");
+  if (value.stateId !== stateId) throw new TypeError("IndexedDB durability owner ID mismatch");
+  return Object.freeze({
+    ownerId: requireId(value.ownerId, "durability owner ID"),
+    fence: durabilityRevision(value.fence),
+  });
+}
+
+function exactRecord(value, expected, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError(`${label} must be an object`);
+  }
+  const actual = Object.keys(value).sort();
+  const required = [...expected].sort();
+  if (actual.length !== required.length || actual.some((key, index) => key !== required[index])) {
+    throw new TypeError(`${label} has an invalid shape`);
+  }
+}
+
+function requestResult(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB durability request failed"));
+  });
+}
+
+function transactionCompletion(transaction) {
+  return new Promise((resolve, reject) => {
+    transaction.oncomplete = () => resolve();
+    transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB durability transaction failed"));
+    transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB durability transaction was aborted"));
+  });
+}
+
+function requireId(value, label) {
+  if (typeof value !== "string" || !value.trim()) throw new TypeError(`${label} must be a non-empty string`);
+  return value;
+}
+
+function requirePayload(value) {
+  if (typeof value !== "string") throw new TypeError("durability payload must be a string");
+  return value;
+}

package/vendor/nanocodex/browser/workspace.d.mts

@@ -0,0 +1,16 @@
+import type { Workspace, WorkspaceBackend, WorkspaceEntry } from "../runtime/workspace.mjs";
+
+export { tools } from "../runtime/workspace.mjs";
+
+type OpfsStorage = {
+  getDirectory(): Promise<FileSystemDirectoryHandle>;
+};
+
+export function open(options?: {
+  name?: string | undefined;
+  root?: string | undefined;
+  /** Primarily useful for non-DOM hosts and deterministic tests. */
+  storage?: OpfsStorage | undefined;
+}): Promise<Workspace>;
+
+export type { Workspace, WorkspaceBackend, WorkspaceEntry };

package/vendor/nanocodex/browser/workspace.mjs

@@ -0,0 +1,107 @@
+import { createWorkspace, normalizeRelativePath, tools } from "../runtime/workspace.mjs";
+
+const WORKSPACE_DIRECTORY = "nanocodex-workspaces";
+
+export { tools };
+
+export async function open(options = {}) {
+  const name = workspaceName(options.name ?? "default");
+  const storage = options.storage ?? globalThis.navigator?.storage;
+  if (!storage || typeof storage.getDirectory !== "function") {
+    throw new Error("Origin Private File System storage is unavailable in this browser");
+  }
+  const origin = await storage.getDirectory();
+  const workspaces = await origin.getDirectoryHandle(WORKSPACE_DIRECTORY, { create: true });
+  const directory = await workspaces.getDirectoryHandle(encodeURIComponent(name), { create: true });
+  return createWorkspace({
+    root: options.root ?? "/workspace",
+    backend: opfsBackend(directory),
+  });
+}
+
+function opfsBackend(root) {
+  return {
+    async list(path, { recursive, maxEntries }) {
+      const directory = await directoryHandle(root, path, false);
+      const entries = [];
+      await listDirectory(directory, path, recursive, maxEntries, entries);
+      return entries.sort((left, right) => left.path.localeCompare(right.path));
+    },
+    async readFile(path) {
+      const { directory, name } = await parentHandle(root, path, false);
+      const handle = await directory.getFileHandle(name);
+      return new Uint8Array(await (await handle.getFile()).arrayBuffer());
+    },
+    async writeFile(path, contents) {
+      const { directory, name } = await parentHandle(root, path, true);
+      const handle = await directory.getFileHandle(name, { create: true });
+      const writable = await handle.createWritable();
+      try {
+        await writable.write(contents);
+        await writable.close();
+      } catch (error) {
+        await writable.abort?.().catch(() => {});
+        throw error;
+      }
+    },
+    async remove(path, { recursive }) {
+      const { directory, name } = await parentHandle(root, path, false);
+      await directory.removeEntry(name, { recursive });
+    },
+    async mkdir(path) {
+      await directoryHandle(root, path, true);
+    },
+  };
+}
+
+async function listDirectory(directory, prefix, recursive, maxEntries, output) {
+  for await (const [name, handle] of directory.entries()) {
+    if (output.length >= maxEntries) {
+      throw new RangeError(`workspace listing exceeds ${maxEntries} entries`);
+    }
+    const path = prefix ? `${prefix}/${name}` : name;
+    if (handle.kind === "directory") {
+      output.push({ kind: "directory", path });
+      if (recursive) await listDirectory(handle, path, true, maxEntries, output);
+      continue;
+    }
+    if (handle.kind !== "file") throw new Error(`unsupported workspace entry kind: ${handle.kind}`);
+    const file = await handle.getFile();
+    output.push({
+      kind: "file",
+      modifiedAt: file.lastModified,
+      path,
+      size: file.size,
+    });
+  }
+}
+
+async function directoryHandle(root, path, create) {
+  let directory = root;
+  const relative = normalizeRelativePath(path);
+  if (!relative) return directory;
+  for (const segment of relative.split("/")) {
+    directory = await directory.getDirectoryHandle(segment, { create });
+  }
+  return directory;
+}
+
+async function parentHandle(root, path, create) {
+  const relative = normalizeRelativePath(path);
+  const segments = relative.split("/");
+  const name = segments.pop();
+  if (!name) throw new Error("workspace file path cannot be empty");
+  return {
+    directory: await directoryHandle(root, segments.join("/"), create),
+    name,
+  };
+}
+
+function workspaceName(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new TypeError("workspace name must be a non-empty string");
+  }
+  if (value.length > 128) throw new RangeError("workspace name cannot exceed 128 characters");
+  if (value.includes("\0")) throw new TypeError("workspace name cannot contain NUL");
+  return value;
+}

package/vendor/nanocodex/cloud/Client.d.mts

@@ -0,0 +1,83 @@
+import type { ConnectActions } from "./Decorator.mjs";
+import type { Instance as DialogInstance, Dialog } from "./Dialog.mjs";
+import type { Instance as PrincipalInstance, Principal } from "./Principal.mjs";
+import type { Request, Transport } from "./Transport.mjs";
+import type { Auth, AuthorizeAccessKey } from "./actions/connection.mjs";
+import type { HostConnection } from "./types.mjs";
+
+export type Provider = Readonly<{
+  request(request: Readonly<{
+    method: string;
+    params?: readonly unknown[] | undefined;
+    context?: Readonly<Record<string, unknown>> | undefined;
+  }>): Promise<unknown>;
+  /** Internal lifecycle reset used after account logout. */
+  reset?(): Promise<void>;
+  store?: Readonly<{
+    getState?(): Readonly<{
+      accounts?: readonly Readonly<{ address: string }>[] | undefined;
+      activeAccount?: number | undefined;
+      accessKeys?: readonly Readonly<{
+        access: string;
+        address: string;
+        chainId: number;
+        expiry: number;
+      }>[] | undefined;
+    }>;
+  }> | undefined;
+}>;
+
+export type Base<principal extends PrincipalInstance | undefined = PrincipalInstance | undefined> = Readonly<{
+  appId: string;
+  appOrigin: string | undefined;
+  accessKey: Readonly<{ authorize?: AuthorizeAccessKey | undefined }> | undefined;
+  auth: Auth | undefined;
+  dialog: DialogInstance;
+  key: string;
+  name: string;
+  principal: principal;
+  provider: Provider;
+  type: "connect";
+  uid: string;
+  transport: Readonly<{ key: string; name: string; type: string; baseUrl: string }>;
+  fetch(input: RequestInfo | URL, init?: RequestInit | undefined): Promise<Response>;
+  request(request: Request): Promise<unknown>;
+}>;
+
+export type Client<
+  extension extends object = ConnectActions,
+  principal extends PrincipalInstance | undefined = undefined,
+> = Base<principal> & extension & {
+  extend<next extends object>(decorator: (client: Client<extension, principal>) => next): Client<extension & next, principal>;
+};
+
+type BaseParameters = Readonly<{
+  appId: string;
+  /** Exact browser origin bound into approvals and grants. Defaults to location.origin. */
+  appOrigin?: string | undefined;
+  /** Accounts-compatible default SIWE round-trip configuration. */
+  auth?: Auth | undefined;
+  /** Accounts-compatible default access-key authorization policy. */
+  accessKey?: Readonly<{ authorize?: AuthorizeAccessKey | undefined }> | undefined;
+  dialog?: Dialog | undefined;
+  key?: string | undefined;
+  name?: string | undefined;
+  /** Advanced override for the remote wallet provider that owns the access key. */
+  provider?: Provider | undefined;
+  /** App-scoped grant session persistence. Defaults to browser localStorage. */
+  session?: Pick<Storage, "getItem" | "setItem" | "removeItem"> | false | undefined;
+  transport?: Transport | undefined;
+}>;
+
+export type Parameters<principal extends Principal | undefined = undefined> = BaseParameters & (
+  principal extends Principal
+    ? Readonly<{
+      /** Existing host login used only for hosted, principal-scoped authorization. */
+      principal: principal;
+    }>
+    : Readonly<{ principal?: undefined }>
+);
+
+export function create(parameters: Parameters<Principal<"host">>): Client<ConnectActions<HostConnection>, PrincipalInstance>;
+export function create(parameters: Parameters): Client;
+export function create(parameters: Parameters<Principal>): Client<ConnectActions<HostConnection>, PrincipalInstance>;