@nyte-ai/host 0.0.0-stage → 0.0.18

package/dist/chunks/canvas-preview-5hxat7hh.js

@@ -0,0 +1,239 @@
+import {
+  cacheSavings2,
+  usageTokens2
+} from "./canvas-preview-srgfpdmf.js";
+import {
+  decodeEvent2,
+  parseNumber2,
+  parseText2
+} from "./canvas-preview-69fkk9yn.js";
+
+// src/store-usage.ts
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import {
+  decodeObject,
+  decodeSessionRecord,
+  decodeWorkspaceRecord,
+  parseSessionRef
+} from "@nyte-ai/core/store";
+var EMPTY_TOTALS = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  reasoning: 0,
+  tokens: 0,
+  cost: 0,
+  cacheSavings: 0
+};
+function add(totals, usage) {
+  return {
+    input: totals.input + usage.input,
+    output: totals.output + usage.output,
+    cacheRead: totals.cacheRead + usage.cacheRead,
+    cacheWrite: totals.cacheWrite + usage.cacheWrite,
+    reasoning: totals.reasoning + (usage.reasoning ?? 0),
+    tokens: totals.tokens + usageTokens2(usage),
+    cost: totals.cost + usage.cost.total,
+    cacheSavings: totals.cacheSavings + cacheSavings2(usage)
+  };
+}
+var USAGE_EVENTS2 = "SELECT session, seq, at, event FROM log WHERE json_extract(event, '$.kind') = 'request' OR (json_extract(event, '$.kind') = 'run' AND json_extract(event, '$.change') = 'started') ORDER BY session, seq";
+function localDay2(at) {
+  const date = new Date(at);
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${String(date.getFullYear())}-${month}-${day}`;
+}
+function shiftDay2(day, delta) {
+  const date = new Date(`${day}T00:00:00`);
+  date.setDate(date.getDate() + delta);
+  return localDay2(date.getTime());
+}
+function priorWindow(sinceDay, untilDay) {
+  if (sinceDay === null)
+    return;
+  const priorUntil = shiftDay2(sinceDay, -1);
+  const span = (Date.parse(`${untilDay}T00:00:00Z`) - Date.parse(`${sinceDay}T00:00:00Z`)) / 86400000 + 1;
+  return { sinceDay: shiftDay2(priorUntil, -(span - 1)), untilDay: priorUntil };
+}
+function projectUsageReport2(stores, window, readAt) {
+  const requestedSince = window.sinceDay;
+  const untilDay = window.untilDay;
+  const prior = priorWindow(requestedSince, untilDay);
+  const cells = new Map;
+  const sessions = new Map;
+  const sources = [];
+  let priorCost = 0;
+  let priorTokens = 0;
+  let sawPrior = false;
+  let earliestDay;
+  for (const store of stores) {
+    sources.push({
+      workspacePath: store.workspacePath,
+      status: store.failure === null ? "ok" : "failed",
+      sessions: store.sessions.length,
+      message: store.failure?.message ?? null
+    });
+    for (const session of store.sessions) {
+      let lastActivityAt = 0;
+      let spentInWindow = false;
+      for (const spend of session.records) {
+        const { usage } = spend;
+        const amounts = [
+          usage.total,
+          usage.input,
+          usage.output,
+          usage.cacheRead,
+          usage.cacheWrite,
+          usage.cost.total
+        ];
+        if (!amounts.some((amount) => amount > 0))
+          continue;
+        const day = localDay2(spend.at);
+        if (earliestDay === undefined || day < earliestDay)
+          earliestDay = day;
+        if (prior !== undefined && day >= prior.sinceDay && day <= prior.untilDay) {
+          sawPrior = true;
+          priorCost += spend.usage.cost.total;
+          priorTokens += usageTokens2(spend.usage);
+        }
+        if (day > untilDay)
+          continue;
+        if (requestedSince !== null && day < requestedSince)
+          continue;
+        const key = JSON.stringify([day, store.workspacePath, session.sessionId, spend.subject]);
+        const cell = cells.get(key);
+        if (cell === undefined) {
+          cells.set(key, {
+            entry: {
+              day,
+              workspacePath: store.workspacePath,
+              sessionId: session.sessionId,
+              subject: spend.subject
+            },
+            totals: add(EMPTY_TOTALS, spend.usage)
+          });
+        } else {
+          cell.totals = add(cell.totals, spend.usage);
+        }
+        spentInWindow = true;
+        lastActivityAt = Math.max(lastActivityAt, spend.at);
+      }
+      if (spentInWindow) {
+        sessions.set(session.sessionId, {
+          sessionId: session.sessionId,
+          name: session.name,
+          workspacePath: store.workspacePath,
+          lastActivityAt: session.lastActivityAt ?? lastActivityAt
+        });
+      }
+    }
+  }
+  return {
+    readAt,
+    sinceDay: requestedSince ?? earliestDay ?? untilDay,
+    untilDay,
+    entries: [...cells.values()].map((cell) => ({ ...cell.entry, totals: cell.totals })).toSorted((left, right) => left.day.localeCompare(right.day)),
+    sessions: [...sessions.values()],
+    sources,
+    previous: sawPrior ? { cost: priorCost, tokens: priorTokens } : undefined,
+    earliestDay
+  };
+}
+function readNyteUsage2(home, window) {
+  const readAt = Date.now();
+  const path = join(home, ".nyte", "nyte.db");
+  if (!existsSync(path))
+    return projectUsageReport2([], window, readAt);
+  let database;
+  try {
+    database = new DatabaseSync(path, { readOnly: true, timeout: 5000 });
+    database.exec("BEGIN");
+    const workspaces = new Map;
+    const sessions = new Map;
+    const refs = database.prepare("SELECT refs.name, objects.body FROM refs JOIN objects ON objects.id = refs.target WHERE refs.name LIKE 'workspaces/%' OR (refs.name LIKE 'sessions/%' AND instr(substr(refs.name, 10), '/') = 0)").all();
+    for (const row of refs) {
+      const name = parseText2(row.name);
+      const body = parseText2(row.body);
+      if (name === null || body === null || !name.startsWith("workspaces/"))
+        continue;
+      const workspace = decodeWorkspaceRecord(decodeObject(body));
+      if (workspace !== null)
+        workspaces.set(workspace.id, workspace.target.kind === "local" && "path" in workspace.target ? parseText2(workspace.target.path) : null);
+    }
+    for (const row of refs) {
+      const name = parseText2(row.name);
+      const body = parseText2(row.body);
+      if (name === null || body === null || name.split("/").length !== 2)
+        continue;
+      const id = parseSessionRef(name);
+      if (id === null)
+        continue;
+      const session = decodeSessionRecord(decodeObject(body));
+      if (session === null)
+        throw new Error(`Cannot read session ${id}.`);
+      sessions.set(id, {
+        workspacePath: workspaces.get(session.workspace) ?? null,
+        name: session.name ?? undefined,
+        lastActivityAt: session.lastActivityAt,
+        records: []
+      });
+    }
+    const models = new Map;
+    for (const row of database.prepare(USAGE_EVENTS2).iterate()) {
+      const session = parseSessionRef(`sessions/${parseText2(row.session) ?? ""}`);
+      if (session === null)
+        throw new Error("Cannot read usage session.");
+      const event = decodeEvent2(parseNumber2(row.seq), parseNumber2(row.at), parseText2(row.event) ?? "");
+      let heads = models.get(session);
+      if (heads === undefined) {
+        heads = new Map;
+        models.set(session, heads);
+      }
+      if (event.kind === "run" && event.change === "started")
+        heads.set(event.head, event.view.configuration.model);
+      if (event.kind !== "request")
+        continue;
+      const model = heads.get(event.head);
+      const subject = event.step === "compaction" || event.step === "summary" ? { kind: "compaction" } : event.step === "plugin" ? { kind: "tool" } : {
+        kind: "model",
+        provider: model?.provider ?? "unknown",
+        model: model?.id ?? "unknown"
+      };
+      let info = sessions.get(session);
+      if (info === undefined) {
+        info = { workspacePath: null, name: undefined, lastActivityAt: undefined, records: [] };
+        sessions.set(session, info);
+      }
+      info.records.push({ at: event.at, subject, usage: event.usage });
+    }
+    database.exec("COMMIT");
+    const stores = new Map;
+    for (const [sessionId, info] of sessions) {
+      const group = stores.get(info.workspacePath) ?? [];
+      group.push({
+        sessionId,
+        name: info.name,
+        records: info.records,
+        lastActivityAt: info.lastActivityAt
+      });
+      stores.set(info.workspacePath, group);
+    }
+    return projectUsageReport2([...stores].map(([workspacePath, sessions]) => ({ workspacePath, sessions, failure: null })), window, readAt);
+  } catch (cause) {
+    return projectUsageReport2([
+      {
+        workspacePath: null,
+        sessions: [],
+        failure: { message: cause instanceof Error ? cause.message : String(cause) }
+      }
+    ], window, readAt);
+  } finally {
+    database?.close();
+  }
+}
+
+export { USAGE_EVENTS2, localDay2, shiftDay2, projectUsageReport2, readNyteUsage2 };

package/dist/chunks/canvas-preview-5mex725c.js

@@ -0,0 +1,14 @@
+import {
+  seedSigner2
+} from "./canvas-preview-31w7xm8z.js";
+import {
+  readKeyFile2
+} from "./canvas-preview-wg80rbc2.js";
+
+// src/identity-key.ts
+import { join } from "node:path";
+async function identitySigner2(id, home) {
+  return seedSigner2(id, await readKeyFile2(join(home, ".nyte", "identity.key"), "identity key"));
+}
+
+export { identitySigner2 };

package/dist/chunks/canvas-preview-5z63am63.js

@@ -0,0 +1,295 @@
+// src/mcp/oauth.ts
+import { createHash } from "node:crypto";
+import {
+  McpOAuthAuthorizationRequiredError,
+  McpOAuthProvider,
+  OAuthCallbackServer,
+  authorizeMcp,
+  parseWwwAuthenticate,
+  stepUpScope
+} from "@earendil-works/pi-mcp/oauth";
+import { closable } from "@nyte-ai/core";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var CALLBACK_HOST = "127.0.0.1";
+var CALLBACK_PATH = "/callback";
+var FALLBACK_REDIRECT_URL = `http://${CALLBACK_HOST}${CALLBACK_PATH}`;
+var REFRESH_SKEW_MS = 30000;
+var REQUEST_TIMEOUT_MS = 15000;
+var SIGN_IN_TIMEOUT_MS = 5 * 60 * 1000;
+var tokens = Type.Object({
+  access_token: Type.String(),
+  token_type: Type.String(),
+  expires_in: Type.Optional(Type.Number()),
+  scope: Type.Optional(Type.String()),
+  refresh_token: Type.Optional(Type.String()),
+  id_token: Type.Optional(Type.String())
+});
+var storedState = Type.Object({
+  serverUrl: Type.String(),
+  clientInformation: Type.Optional(Type.Object({
+    client_id: Type.String(),
+    client_secret: Type.Optional(Type.String()),
+    client_id_issued_at: Type.Optional(Type.Number()),
+    client_secret_expires_at: Type.Optional(Type.Number()),
+    redirect_uris: Type.Optional(Type.Array(Type.String()))
+  })),
+  tokens: Type.Optional(tokens),
+  tokensExpireAt: Type.Optional(Type.Number()),
+  codeVerifier: Type.Optional(Type.String()),
+  oauthState: Type.Optional(Type.String())
+});
+function oauthKey2(server, url) {
+  return `oauth:${server}:${createHash("sha256").update(url).digest("hex").slice(0, 16)}`;
+}
+function oauthStore2(secrets, key) {
+  return {
+    async load() {
+      const text = await secrets.get(key);
+      const parsed = text === undefined ? undefined : JSON.parse(text);
+      return Value.Check(storedState, parsed) ? parsed : undefined;
+    },
+    save: (state) => secrets.set(key, JSON.stringify({ ...state, discovery: undefined }))
+  };
+}
+function createAuthProvider2(input) {
+  const { serverUrl, store } = input;
+  let refreshing;
+  const refresh = (stale, fetch = globalThis.fetch, challenge) => {
+    refreshing ??= (async () => {
+      const state = await store.load();
+      if (state?.tokens?.access_token !== stale)
+        return;
+      if (state?.tokens?.refresh_token === undefined)
+        throw new McpOAuthAuthorizationRequiredError;
+      const settings = input.settings();
+      const redirectUrl = fixedRedirectUrl(settings) ?? registeredRedirectUrls(state.clientInformation)[0] ?? FALLBACK_REDIRECT_URL;
+      const provider = createProvider(serverUrl, store, settings, redirectUrl, () => {
+        return;
+      });
+      const result = await authorizeMcp(provider, {
+        serverUrl,
+        resourceMetadataUrl: challenge?.resourceMetadataUrl,
+        authorizationServerMetadataUrl: settings.authServerMetadataUrl,
+        scope: challenge?.scope,
+        fetch: timedFetch(fetch)
+      });
+      if (result === "REDIRECT")
+        throw new McpOAuthAuthorizationRequiredError;
+    })().finally(() => {
+      refreshing = undefined;
+    });
+    return refreshing;
+  };
+  return {
+    async token() {
+      await refreshing?.catch(() => {
+        return;
+      });
+      const state = await store.load();
+      const token = state?.tokens?.access_token;
+      const expired = state?.tokensExpireAt !== undefined && state.tokensExpireAt - REFRESH_SKEW_MS <= Date.now();
+      if (!expired || state?.tokens?.refresh_token === undefined)
+        return token;
+      await refresh(token).catch(() => {
+        return;
+      });
+      return (await store.load())?.tokens?.access_token;
+    },
+    async onUnauthorized(context) {
+      const challenge = parseWwwAuthenticate(context.response.headers.get("www-authenticate"));
+      input.onChallenge(challenge);
+      if (challenge.error === "insufficient_scope")
+        throw new McpOAuthAuthorizationRequiredError;
+      await refresh(context.token, context.fetch, challenge);
+    }
+  };
+}
+function signIn2(input) {
+  const queued = [];
+  const wakers = new Set;
+  let pasted = null;
+  const controller = new AbortController;
+  const wakeAll = () => {
+    for (const wake of wakers)
+      wake();
+    wakers.clear();
+  };
+  const deliver = (step) => {
+    queued.push(step);
+    wakeAll();
+  };
+  (async () => {
+    try {
+      await authorize({
+        ...input,
+        signal: controller.signal,
+        show(url) {
+          deliver({ kind: "open", url: url.href });
+          pasted = Promise.withResolvers();
+          deliver({
+            kind: "paste",
+            message: "If the browser can't reach this machine, paste the URL it ended on",
+            secret: false
+          });
+          return pasted.promise;
+        }
+      });
+      input.signedIn();
+      deliver({ kind: "done" });
+    } catch (error) {
+      deliver({
+        kind: "failed",
+        reason: controller.signal.aborted ? "Sign-in cancelled." : `Sign-in to ${input.server} failed: ${error instanceof Error ? error.message : String(error)}`
+      });
+    } finally {
+      input.ended();
+    }
+  })();
+  return {
+    steps: () => closable(() => {
+      let finished = false;
+      return {
+        async pull() {
+          if (finished)
+            return { done: true, value: undefined };
+          let step = queued.shift();
+          while (step === undefined && !controller.signal.aborted) {
+            await new Promise((resolve) => wakers.add(resolve));
+            step = queued.shift();
+          }
+          if (step === undefined)
+            return { done: true, value: undefined };
+          finished = step.kind === "done" || step.kind === "failed";
+          return { done: false, value: step };
+        },
+        close() {
+          controller.abort();
+          wakeAll();
+        }
+      };
+    }),
+    async answer(code) {
+      pasted?.resolve(code);
+    }
+  };
+}
+async function authorize(input) {
+  const { serverUrl, store, settings, challenge, signal } = input;
+  const stored = await store.load();
+  const stepUp = challenge?.error === "insufficient_scope";
+  const fixed = fixedRedirectUrl(settings);
+  const configured = new URL(settings.callbackUrl ?? `http://${CALLBACK_HOST}${CALLBACK_PATH}`);
+  const registered = registeredRedirectUrls(stored?.clientInformation)[0];
+  const configuredPort = configured.port === "" ? settings.callbackPort : Number(configured.port);
+  const preferred = configuredPort ?? (registered === undefined ? undefined : Number(new URL(registered).port) || undefined);
+  const callback = await listen(configured, preferred, configuredPort !== undefined);
+  const redirectUrl = fixed ?? callback.redirectUrl;
+  try {
+    if (stored !== undefined) {
+      const keep = settings.clientId !== undefined || registeredRedirectUrls(stored.clientInformation).includes(redirectUrl);
+      const next = keep ? { ...stored, oauthState: undefined } : { serverUrl: stored.serverUrl };
+      await store.save(next);
+    }
+    let authorizationUrl;
+    const provider = createProvider(serverUrl, store, settings, redirectUrl, (url) => {
+      authorizationUrl = url;
+    });
+    const flow = {
+      serverUrl,
+      fetch: timedFetch(),
+      signal,
+      resourceMetadataUrl: challenge?.resourceMetadataUrl,
+      authorizationServerMetadataUrl: settings.authServerMetadataUrl,
+      scope: mergeScopes(settings.scope, stepUp ? stepUpScope(stored?.tokens?.scope, challenge?.scope) : challenge?.scope)
+    };
+    if (await authorizeMcp(provider, { ...flow, skipRefresh: stepUp }) === "AUTHORIZED")
+      return;
+    if (authorizationUrl === undefined)
+      throw new Error("The server did not give an authorization page.");
+    const state = await provider.state();
+    const expected = new URL(authorizationUrl.searchParams.get("redirect_uri") ?? redirectUrl);
+    signal.throwIfAborted();
+    const pasted = input.show(authorizationUrl);
+    const response = await Promise.race([
+      callback.waitForCallback(state, expected.pathname),
+      pasted.then((text) => fromRedirectUrl(text, state, expected)),
+      new Promise((_resolve, reject) => signal.addEventListener("abort", () => reject(new Error("Sign-in cancelled.")), {
+        once: true
+      }))
+    ]);
+    await authorizeMcp(provider, { ...flow, authorizationCode: response.code, iss: response.iss });
+  } finally {
+    await callback.close();
+  }
+}
+function fromRedirectUrl(text, state, expected) {
+  const url = URL.parse(text.trim());
+  if (url === null)
+    throw new Error("Paste the full URL from the browser's address bar.");
+  if (url.origin !== expected.origin || url.pathname !== expected.pathname)
+    throw new Error("That URL is not this sign-in's redirect.");
+  const error = url.searchParams.get("error");
+  if (error !== null)
+    throw new Error(url.searchParams.get("error_description") ?? error);
+  if (url.searchParams.get("state") !== state)
+    throw new Error("That URL belongs to a different sign-in.");
+  const code = url.searchParams.get("code");
+  if (code === null)
+    throw new Error("That URL has no authorization code.");
+  return { code, iss: url.searchParams.get("iss") ?? undefined };
+}
+async function listen(configured, port, required) {
+  const address = configured.hostname.replace(/^\[|\]$/g, "");
+  const options = {
+    host: address === "localhost" ? CALLBACK_HOST : address,
+    redirectHost: address,
+    path: configured.pathname,
+    timeoutMs: SIGN_IN_TIMEOUT_MS
+  };
+  try {
+    return await OAuthCallbackServer.listen({ ...options, port: port ?? 0 });
+  } catch (error) {
+    if (required || port === undefined)
+      throw error;
+    return OAuthCallbackServer.listen(options);
+  }
+}
+function fixedRedirectUrl(settings) {
+  if (settings.callbackUrl !== undefined && new URL(settings.callbackUrl).port !== "")
+    return settings.callbackUrl;
+  if (settings.callbackPort === undefined)
+    return;
+  const url = new URL(settings.callbackUrl ?? `http://${CALLBACK_HOST}${CALLBACK_PATH}`);
+  url.port = String(settings.callbackPort);
+  return url.href;
+}
+function createProvider(serverUrl, store, settings, redirectUrl, onRedirect) {
+  return new McpOAuthProvider({
+    serverUrl,
+    redirectUrl,
+    clientMetadata: { client_name: settings.clientName ?? "Nyte" },
+    clientId: settings.clientId,
+    clientSecret: settings.clientSecret,
+    store,
+    onRedirect
+  });
+}
+function registeredRedirectUrls(client) {
+  return client !== undefined && "redirect_uris" in client ? client.redirect_uris : [];
+}
+function mergeScopes(...scopes) {
+  const merged = [...new Set(scopes.flatMap((scope) => scope?.split(/\s+/).filter(Boolean) ?? []))];
+  return merged.length > 0 ? merged.join(" ") : undefined;
+}
+function timedFetch(fetch = globalThis.fetch) {
+  return (url, init) => {
+    const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+    return fetch(url, {
+      ...init,
+      signal: init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout
+    });
+  };
+}
+
+export { oauthKey2, oauthStore2, createAuthProvider2, signIn2 };

package/dist/chunks/canvas-preview-65xqjw7f.js

@@ -0,0 +1,20 @@
+// src/deploy/vercel/server/utils/step.ts
+function stepFrom2(report, now) {
+  switch (report.kind) {
+    case "continue":
+      return { kind: "advance" };
+    case "waiting":
+      return report.until === null ? { kind: "stop" } : untilStep(report.until, now);
+    case "retry":
+      return untilStep(report.until, now);
+    case "busy":
+    case "idle":
+    case "fenced":
+      return { kind: "stop" };
+  }
+}
+function untilStep(until, now) {
+  return until > now ? { kind: "sleep", ms: until - now } : { kind: "advance" };
+}
+
+export { stepFrom2 };

package/dist/chunks/canvas-preview-69fkk9yn.js

@@ -0,0 +1,95 @@
+// src/store-rows.ts
+import { asId, SdkError } from "@nyte-ai/schema";
+import { loggedEvent } from "@nyte-ai/core/store";
+function prefixEnd2(prefix) {
+  const points = Array.from(prefix);
+  const last = points.pop()?.codePointAt(0);
+  if (last === undefined)
+    return null;
+  if (last === 1114111)
+    return prefixEnd2(points.join(""));
+  return points.join("") + String.fromCodePoint(last === 55295 ? 57344 : last + 1);
+}
+function mintRevision2() {
+  return asId(crypto.randomUUID());
+}
+function decodeEvent2(seq, at, text) {
+  return loggedEvent(seq, at, JSON.parse(text));
+}
+function parseNumber2(value) {
+  if (typeof value === "number")
+    return value;
+  if (typeof value === "bigint" || typeof value === "string")
+    return Number(value);
+  throw new SdkError("internal", "A stored number is malformed.");
+}
+function parseText2(value) {
+  if (value === null || value === undefined)
+    return null;
+  if (typeof value === "string")
+    return value;
+  throw new SdkError("internal", "A stored text column is malformed.");
+}
+function parseRef2(row) {
+  const name = parseText2(row.name);
+  const revision = parseText2(row.revision);
+  const target = parseText2(row.target);
+  if (name === null || revision === null)
+    throw new SdkError("internal", "A stored ref is malformed.");
+  return {
+    name,
+    target: target === null ? null : asId(target),
+    revision: asId(revision)
+  };
+}
+function parseStoredRecord2(row) {
+  const name = parseText2(row.name);
+  const target = parseText2(row.target);
+  const revision = parseText2(row.revision);
+  const body = parseText2(row.body);
+  if (name === null || target === null || revision === null || body === null)
+    throw new SdkError("internal", "A stored ref is malformed.");
+  return { name, target: asId(target), revision, body };
+}
+function parseStoredObject2(row) {
+  const id = parseText2(row.id);
+  const body = parseText2(row.body);
+  if (id === null || body === null)
+    throw new SdkError("internal", "A stored object is malformed.");
+  return { id: asId(id), body };
+}
+function loggedRow2(row) {
+  const event = parseText2(row.event);
+  if (event === null)
+    throw new SdkError("internal", "A logged event is malformed.");
+  return { seq: parseNumber2(row.seq), event };
+}
+async function collect2(bytes) {
+  const chunks = [];
+  for await (const chunk of bytes)
+    chunks.push(chunk);
+  const joined = new Uint8Array(chunks.reduce((size, chunk) => size + chunk.byteLength, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    joined.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return joined;
+}
+function memoryReader2(bytes) {
+  return {
+    size: bytes.byteLength,
+    mime: null,
+    async* chunks() {
+      yield bytes;
+    },
+    close: async () => {
+      return;
+    },
+    [Symbol.asyncDispose]: async () => {
+      return;
+    }
+  };
+}
+
+export { prefixEnd2, mintRevision2, decodeEvent2, parseNumber2, parseText2, parseRef2, parseStoredRecord2, parseStoredObject2, loggedRow2, collect2, memoryReader2 };