stitchkit 0.93.0 → 0.94.1

package/dist/index-2c2bjw3s.js

@@ -1,51 +0,0 @@
-import {
-  contractToolMountable
-} from "./index-mzvgxp0n.js";
-import {
-  runtimeToolMountable
-} from "./index-vjpvjqpn.js";
-import {
-  projectToolSurface
-} from "./index-h9etkkyk.js";
-
-// src/tools/surface.ts
-function collectToolSurface({
-  surface,
-  transport,
-  assertUniqueNames = true,
-  ...collectConfig
-}) {
-  const entries = [];
-  const append = (entry) => {
-    entries.push(entry);
-  };
-  for (const projected of projectToolSurface(surface, transport, {
-    extend: collectConfig.extend,
-    flattenUnionInput: collectConfig.flattenUnionInput,
-    assertNames: collectConfig.assertNames,
-    assertUniqueNames
-  })) {
-    if (projected.kind === "contract") {
-      const mountable = contractToolMountable(projected, collectConfig.extend);
-      append({
-        kind: "contract",
-        service: projected.serviceName,
-        action: mountable.method.key,
-        mountable,
-        projection: projected
-      });
-    } else {
-      append({
-        kind: "runtime",
-        service: projected.serviceName,
-        action: projected.action,
-        mountable: runtimeToolMountable(projected.source, false),
-        definition: projected.source,
-        projection: projected
-      });
-    }
-  }
-  return entries;
-}
-
-export { collectToolSurface };

package/dist/index-2na0qrfn.js

@@ -1,214 +0,0 @@
-import {
-  LiveStatePhaseSchema,
-  LiveStateStopReasonSchema
-} from "./index-ywd0y6m1.js";
-import {
-  stableValue
-} from "./index-a916km3r.js";
-
-// src/live/watch-delta.ts
-import { z } from "zod";
-var WatchDeltaSchema = z.lazy(() => z.union([
-  z.object({ t: z.literal("set"), v: z.unknown() }),
-  z.object({
-    t: z.literal("obj"),
-    set: z.record(z.string(), WatchDeltaSchema).optional(),
-    drop: z.array(z.string()).optional()
-  }),
-  z.object({ t: z.literal("arr"), ops: z.array(WatchArrayOpSchema) })
-]));
-var WatchArrayOpSchema = z.lazy(() => z.union([
-  z.object({
-    o: z.literal("copy"),
-    from: z.number().int().nonnegative(),
-    count: z.number().int().positive()
-  }),
-  z.object({
-    o: z.literal("patch"),
-    from: z.number().int().nonnegative(),
-    d: WatchDeltaSchema
-  }),
-  z.object({ o: z.literal("put"), v: z.unknown() })
-]));
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function signature(value) {
-  return JSON.stringify(stableValue(value)) ?? "undefined";
-}
-function diff(previous, next) {
-  if (signature(previous) === signature(next))
-    return;
-  if (isRecord(previous) && isRecord(next))
-    return objectDiff(previous, next);
-  if (Array.isArray(previous) && Array.isArray(next))
-    return arrayDiff(previous, next);
-  return { t: "set", v: next };
-}
-function objectDiff(previous, next) {
-  const set = {};
-  const drop = [];
-  for (const key of Object.keys(next)) {
-    if (!Object.hasOwn(previous, key)) {
-      set[key] = { t: "set", v: next[key] };
-      continue;
-    }
-    const nested = diff(previous[key], next[key]);
-    if (nested !== undefined)
-      set[key] = nested;
-  }
-  for (const key of Object.keys(previous)) {
-    if (!Object.hasOwn(next, key))
-      drop.push(key);
-  }
-  return {
-    t: "obj",
-    ...Object.keys(set).length > 0 && { set },
-    ...drop.length > 0 && { drop }
-  };
-}
-function arrayDiff(previous, next) {
-  const previousSignatures = previous.map(signature);
-  const positions = new Map;
-  previousSignatures.forEach((value, index) => {
-    const bucket = positions.get(value);
-    if (bucket)
-      bucket.push(index);
-    else
-      positions.set(value, [index]);
-  });
-  const taken = new Set;
-  const ops = [];
-  let cursor = 0;
-  const extend = (from) => {
-    const last = ops.at(-1);
-    if (last?.o !== "copy" || last.from + last.count !== from)
-      return false;
-    ops[ops.length - 1] = { o: "copy", from: last.from, count: last.count + 1 };
-    return true;
-  };
-  for (const element of next) {
-    const wanted = signature(element);
-    const last = ops.at(-1);
-    const continuation = last?.o === "copy" ? last.from + last.count : undefined;
-    if (continuation !== undefined && continuation < previous.length && previousSignatures[continuation] === wanted && !taken.has(continuation)) {
-      taken.add(continuation);
-      extend(continuation);
-      cursor = continuation + 1;
-      continue;
-    }
-    const bucket = positions.get(wanted);
-    const found = bucket?.find((index) => !taken.has(index));
-    if (found !== undefined) {
-      taken.add(found);
-      if (!extend(found))
-        ops.push({ o: "copy", from: found, count: 1 });
-      cursor = found + 1;
-      continue;
-    }
-    const counterpart = cursor < previous.length && !taken.has(cursor) ? cursor : undefined;
-    const nested = counterpart === undefined ? undefined : diff(previous[counterpart], element);
-    if (counterpart !== undefined && nested !== undefined) {
-      taken.add(counterpart);
-      ops.push({ o: "patch", from: counterpart, d: nested });
-      cursor = counterpart + 1;
-      continue;
-    }
-    ops.push({ o: "put", v: element });
-  }
-  return { t: "arr", ops };
-}
-function apply(previous, delta) {
-  if (delta.t === "set")
-    return delta.v;
-  if (delta.t === "obj") {
-    if (!isRecord(previous))
-      throw new Error("an object difference needs an object to apply to");
-    const result2 = { ...previous };
-    for (const key of delta.drop ?? [])
-      delete result2[key];
-    for (const [key, nested] of Object.entries(delta.set ?? {})) {
-      result2[key] = apply(Object.hasOwn(result2, key) ? result2[key] : undefined, nested);
-    }
-    return result2;
-  }
-  if (!Array.isArray(previous))
-    throw new Error("an array difference needs an array to apply to");
-  const result = [];
-  for (const op of delta.ops) {
-    if (op.o === "put") {
-      result.push(op.v);
-      continue;
-    }
-    if (op.from >= previous.length) {
-      throw new Error(`the difference reads element ${op.from} of an array of ${previous.length}`);
-    }
-    if (op.o === "patch") {
-      result.push(apply(previous[op.from], op.d));
-      continue;
-    }
-    if (op.from + op.count > previous.length) {
-      throw new Error(`the difference copies ${op.count} from ${op.from} of an array of ${previous.length}`);
-    }
-    result.push(...previous.slice(op.from, op.from + op.count));
-  }
-  return result;
-}
-function deltaWins(delta, value) {
-  return JSON.stringify(delta).length < (JSON.stringify(value) ?? "null").length;
-}
-
-// src/live/watch-contract.ts
-import { z as z2 } from "zod";
-var WatchKeySchema = z2.object({
-  service: z2.string().min(1),
-  action: z2.string().min(1),
-  digest: z2.string().min(1)
-}).strict().readonly();
-var WatchHaveSchema = z2.object({ revision: z2.number().int().nonnegative(), fingerprint: z2.string().min(1) }).strict().readonly();
-var WatchOpenSchema = z2.object({ key: WatchKeySchema, args: z2.unknown(), have: WatchHaveSchema.optional() }).readonly();
-var WatchAcceptedSchema = z2.object({
-  accepted: z2.boolean(),
-  reason: z2.string().optional()
-}).strict().readonly();
-var watchValueParts = {
-  key: WatchKeySchema,
-  revision: z2.number().int().nonnegative(),
-  fingerprint: z2.string().min(1)
-};
-var WatchValueSchema = z2.discriminatedUnion("kind", [
-  z2.object({ kind: z2.literal("full"), ...watchValueParts, value: z2.unknown() }).readonly(),
-  z2.object({
-    kind: z2.literal("delta"),
-    ...watchValueParts,
-    base: z2.number().int().nonnegative(),
-    delta: WatchDeltaSchema
-  }).readonly(),
-  z2.object({ kind: z2.literal("unchanged"), ...watchValueParts }).readonly()
-]);
-var WatchStateSchema = z2.object({
-  key: WatchKeySchema,
-  phase: LiveStatePhaseSchema,
-  reason: LiveStateStopReasonSchema.optional(),
-  code: z2.string().optional(),
-  message: z2.string().optional()
-}).readonly();
-var WATCH_OPEN = "stitchkit.watch.open";
-var WATCH_CLOSE = "stitchkit.watch.close";
-var WATCH_VALUE = "stitchkit.watch.value";
-var WATCH_STATE = "stitchkit.watch.state";
-var watchContract = {
-  serverToClient: {
-    [WATCH_VALUE]: { args: z2.tuple([WatchValueSchema]) },
-    [WATCH_STATE]: { args: z2.tuple([WatchStateSchema]) }
-  },
-  clientToServer: {
-    [WATCH_OPEN]: { args: z2.tuple([WatchOpenSchema]), ack: WatchAcceptedSchema },
-    [WATCH_CLOSE]: { args: z2.tuple([z2.object({ key: WatchKeySchema }).readonly()]) }
-  }
-};
-function watchKeyString(key) {
-  return `${key.service}/${key.action}/${key.digest}`;
-}
-
-export { WatchDeltaSchema, WatchArrayOpSchema, diff, apply, deltaWins, WatchKeySchema, WatchHaveSchema, WatchValueSchema, WatchStateSchema, WATCH_OPEN, WATCH_CLOSE, WATCH_VALUE, WATCH_STATE, watchContract, watchKeyString };

package/dist/index-2qzskm8h.js

@@ -1,63 +0,0 @@
-// src/realtime/request.ts
-import { z } from "zod";
-var RealtimeRequestPhaseSchema = z.enum([
-  "engine-handoff",
-  "engine-ack-received",
-  "settled",
-  "timeout",
-  "disconnected"
-]);
-var RealtimeRequestPhaseEventSchema = z.object({
-  requestId: z.string().min(1),
-  event: z.string().min(1),
-  phase: RealtimeRequestPhaseSchema,
-  elapsedMs: z.number().finite().nonnegative()
-}).strict();
-
-class RealtimeRequestTimeoutError extends Error {
-  code = "REALTIME_REQUEST_TIMEOUT";
-  event;
-  timeoutMs;
-  constructor(event, timeoutMs) {
-    super(`Realtime request "${event}" timed out after ${timeoutMs}ms`);
-    this.name = "RealtimeRequestTimeoutError";
-    this.event = event;
-    this.timeoutMs = timeoutMs;
-  }
-}
-
-class RealtimeRequestDisconnectedError extends Error {
-  code = "REALTIME_REQUEST_DISCONNECTED";
-  event;
-  constructor(event) {
-    super(`Realtime request "${event}" was interrupted by disconnect`);
-    this.name = "RealtimeRequestDisconnectedError";
-    this.event = event;
-  }
-}
-
-class RealtimeRequestInvalidAcknowledgementError extends Error {
-  code = "REALTIME_REQUEST_INVALID_ACKNOWLEDGEMENT";
-  event;
-  constructor(event, cause) {
-    super(`Realtime request "${event}" received an invalid acknowledgement`, { cause });
-    this.name = "RealtimeRequestInvalidAcknowledgementError";
-    this.event = event;
-  }
-}
-
-class RealtimeRequestRejectedError extends Error {
-  code = "REALTIME_REQUEST_REJECTED";
-  event;
-  reason;
-  issues;
-  constructor(event, reason, detail, issues) {
-    super(`Realtime request "${event}" was rejected by the peer (${reason}): ${detail}`);
-    this.name = "RealtimeRequestRejectedError";
-    this.event = event;
-    this.reason = reason;
-    this.issues = issues;
-  }
-}
-
-export { RealtimeRequestPhaseSchema, RealtimeRequestPhaseEventSchema, RealtimeRequestTimeoutError, RealtimeRequestDisconnectedError, RealtimeRequestInvalidAcknowledgementError, RealtimeRequestRejectedError };