@rivalis/fleet 8.0.0

package/lib/Poller.js

@@ -0,0 +1,113 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/orchestrator/Poller.ts
+var Poller_exports = {};
+__export(Poller_exports, {
+  Poller: () => Poller
+});
+module.exports = __toCommonJS(Poller_exports);
+var FORCE_FULL_EVERY_POLLS = 12;
+var Poller = class {
+  constructor(scheduler, intervalMs, callbacks) {
+    this.scheduler = scheduler;
+    this.intervalMs = intervalMs;
+    this.callbacks = callbacks;
+  }
+  scheduler;
+  intervalMs;
+  callbacks;
+  entries = /* @__PURE__ */ new Map();
+  reqSeq = 0;
+  /** True while the instance is being polled (started and not yet forgotten). */
+  has(instanceId) {
+    return this.entries.has(instanceId);
+  }
+  /** Begin polling an instance: send the first poll now, then one every `intervalMs`. */
+  start(instanceId) {
+    this.entries.set(instanceId, { timer: null, outstandingReqId: null, missed: 0, pollCount: 0 });
+    this.poll(instanceId);
+    this.schedule(instanceId);
+  }
+  /**
+   * Consume the outstanding poll's reply (§7 enforcement). Returns `true` when
+   * `reqId` matches the in-flight poll (resets the missed counter); `false` when it
+   * matches no outstanding poll — an unsolicited / duplicate / post-settle
+   * `fleet/state`, which the caller turns into a kick.
+   */
+  reply(instanceId, reqId) {
+    const entry = this.entries.get(instanceId);
+    if (entry === void 0 || entry.outstandingReqId === null || entry.outstandingReqId !== reqId) {
+      return false;
+    }
+    entry.outstandingReqId = null;
+    entry.missed = 0;
+    return true;
+  }
+  /** Stop polling an instance and cancel its timer (teardown). Idempotent. */
+  forget(instanceId) {
+    const entry = this.entries.get(instanceId);
+    if (entry !== void 0) {
+      this.scheduler.clearTimeout(entry.timer);
+      this.entries.delete(instanceId);
+    }
+  }
+  schedule(instanceId) {
+    const entry = this.entries.get(instanceId);
+    if (entry === void 0) {
+      return;
+    }
+    entry.timer = this.scheduler.setTimeout(() => this.tick(instanceId), this.intervalMs);
+  }
+  tick(instanceId) {
+    const entry = this.entries.get(instanceId);
+    if (entry === void 0) {
+      return;
+    }
+    if (entry.outstandingReqId !== null) {
+      entry.missed += 1;
+      if (entry.missed === 2) {
+        this.callbacks.onStale(instanceId);
+      }
+      if (entry.missed >= 3) {
+        this.callbacks.onEvict(instanceId);
+        return;
+      }
+      this.schedule(instanceId);
+      return;
+    }
+    this.poll(instanceId);
+    this.schedule(instanceId);
+  }
+  poll(instanceId) {
+    const entry = this.entries.get(instanceId);
+    if (entry === void 0) {
+      return;
+    }
+    const reqId = `poll_${++this.reqSeq}`;
+    const forceFull = entry.pollCount % FORCE_FULL_EVERY_POLLS === 0;
+    entry.pollCount += 1;
+    entry.outstandingReqId = reqId;
+    this.callbacks.sendPoll(instanceId, reqId, forceFull);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Poller
+});

package/lib/Snapshot.js

@@ -0,0 +1,471 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/agent/Snapshot.ts
+var Snapshot_exports = {};
+__export(Snapshot_exports, {
+  MAX_SNAPSHOT_BYTES: () => MAX_SNAPSHOT_BYTES,
+  Snapshot: () => Snapshot
+});
+module.exports = __toCommonJS(Snapshot_exports);
+var import_node_crypto2 = require("crypto");
+
+// src/util/canonical.ts
+var import_node_crypto = require("crypto");
+function canonicalize(value) {
+  return encode(value);
+}
+function encode(value) {
+  if (value === null) {
+    return "null";
+  }
+  const type = typeof value;
+  if (type === "string") {
+    return JSON.stringify(value);
+  }
+  if (type === "number") {
+    return Number.isFinite(value) ? String(value) : "null";
+  }
+  if (type === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (type === "bigint") {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((item) => encodeArrayItem(item));
+    return "[" + items.join(",") + "]";
+  }
+  if (type === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    const parts = [];
+    for (const key of keys) {
+      const child = obj[key];
+      if (isSkippable(child)) {
+        continue;
+      }
+      parts.push(JSON.stringify(key) + ":" + encode(child));
+    }
+    return "{" + parts.join(",") + "}";
+  }
+  return "null";
+}
+function encodeArrayItem(item) {
+  return isSkippable(item) ? "null" : encode(item);
+}
+function isSkippable(value) {
+  const type = typeof value;
+  return value === void 0 || type === "function" || type === "symbol";
+}
+function hash64(value) {
+  const digest = (0, import_node_crypto.createHash)("sha256").update(canonicalize(value)).digest();
+  return digest.subarray(0, 8).toString("hex");
+}
+
+// src/util/logger.ts
+var NOOP_LOGGER = {
+  error() {
+  },
+  warning() {
+  },
+  info() {
+  },
+  debug() {
+  },
+  verbose() {
+  },
+  log() {
+  }
+};
+
+// src/util/packageVersion.ts
+var import_node_module = require("module");
+var import_meta = {};
+function packageVersion() {
+  try {
+    const metaUrl = import_meta.url;
+    const req = metaUrl ? (0, import_node_module.createRequire)(metaUrl) : require;
+    const pkg = req("../package.json");
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+// src/wire/topics.ts
+var PROTOCOL_VERSION = 3;
+var Topics = {
+  /** orch → agent: assigns id + heartbeat (poll cadence) on join; followed by the first poll. */
+  hello: "fleet/hello",
+  /** orch → agent: state poll. Carries `knownHash` (dedup) + the last recorded `status` (echo). */
+  poll: "fleet/poll",
+  /** agent → orch: poll reply. Full snapshot when the hash differs from `knownHash`, hash-only otherwise. */
+  state: "fleet/state",
+  /** orch → agent: command push. */
+  cmd: "fleet/cmd",
+  /** agent → orch: command result. */
+  ack: "fleet/ack"
+};
+
+// src/wire/serializer.ts
+var import_node_module2 = require("module");
+var import_meta2 = {};
+var WIRE_MAJOR = PROTOCOL_VERSION;
+var WIRE_MINOR = 0;
+var HEADER_BYTES = 2;
+var Type = {
+  Label: "Label",
+  SyncRoom: "SyncRoom",
+  Capacity: "Capacity",
+  AckRoom: "AckRoom",
+  Hello: "Hello",
+  Poll: "Poll",
+  State: "State",
+  Cmd: "Cmd",
+  Ack: "Ack"
+};
+var TOPIC_TYPE = {
+  [Topics.hello]: Type.Hello,
+  [Topics.poll]: Type.Poll,
+  [Topics.state]: Type.State,
+  [Topics.cmd]: Type.Cmd,
+  [Topics.ack]: Type.Ack
+};
+var serializer = null;
+function getSerializer() {
+  if (serializer !== null) {
+    return serializer;
+  }
+  const metaUrl = import_meta2.url;
+  const req = metaUrl ? (0, import_node_module2.createRequire)(metaUrl) : require;
+  const mod = req("@toolcase/serializer");
+  const Serializer = mod.Serializer ?? mod.default;
+  const F = Serializer.FieldType;
+  const s = new Serializer("fleet");
+  s.define(Type.Label, [
+    { key: "key", type: F.STRING, rule: "optional" },
+    { key: "value", type: F.STRING, rule: "optional" }
+  ]);
+  s.define(Type.SyncRoom, [
+    { key: "id", type: F.STRING, rule: "optional" },
+    { key: "type", type: F.STRING, rule: "optional" },
+    { key: "connections", type: F.UINT32, rule: "optional" },
+    { key: "origin", type: F.STRING, rule: "optional" }
+  ]);
+  s.define(Type.Capacity, [
+    // null = unlimited (§6). Absent on the wire ⇒ null; an explicit 0 ⇒ 0.
+    { key: "maxConnections", type: F.INT32, rule: "optional", default: null },
+    { key: "maxRooms", type: F.INT32, rule: "optional", default: null }
+  ]);
+  s.define(Type.AckRoom, [
+    { key: "id", type: F.STRING, rule: "optional" },
+    { key: "type", type: F.STRING, rule: "optional" }
+  ]);
+  s.define(Type.Hello, [
+    { key: "instanceId", type: F.STRING, rule: "optional" },
+    { key: "protocolVersion", type: F.UINT32, rule: "optional" },
+    { key: "heartbeatMs", type: F.UINT32, rule: "optional" }
+  ]);
+  s.define(Type.Poll, [
+    { key: "reqId", type: F.STRING, rule: "optional" },
+    // Absent ⇒ null (no prior state / forced full, subsumes the old fleet/resync).
+    { key: "knownHash", type: F.STRING, rule: "optional" },
+    { key: "status", type: F.STRING, rule: "optional" }
+  ]);
+  s.define(Type.State, [
+    { key: "reqId", type: F.STRING, rule: "optional" },
+    // full=false is a hash-only liveness reply: the snapshot fields below are
+    // omitted on the wire (preserving the old sync/ping dedup, orch-initiated).
+    { key: "full", type: F.BOOL, rule: "optional" },
+    { key: "seq", type: F.UINT32, rule: "optional" },
+    { key: "hash", type: F.STRING, rule: "optional" },
+    { key: "name", type: F.STRING, rule: "optional" },
+    { key: "processUid", type: F.STRING, rule: "optional" },
+    { key: "agentVersion", type: F.STRING, rule: "optional" },
+    { key: "protocolVersion", type: F.UINT32, rule: "optional" },
+    { key: "endpointUrl", type: F.STRING, rule: "optional" },
+    { key: "labels", type: Type.Label, rule: "repeated" },
+    { key: "capacity", type: Type.Capacity, rule: "optional" },
+    { key: "autoCreate", type: F.BOOL, rule: "optional" },
+    { key: "roomTypes", type: F.STRING, rule: "repeated" },
+    { key: "rooms", type: Type.SyncRoom, rule: "repeated" },
+    { key: "status", type: F.STRING, rule: "optional" }
+  ]);
+  s.define(Type.Cmd, [
+    { key: "cmdId", type: F.STRING, rule: "optional" },
+    { key: "op", type: F.STRING, rule: "optional" },
+    { key: "roomId", type: F.STRING, rule: "optional" },
+    { key: "roomType", type: F.STRING, rule: "optional" }
+  ]);
+  s.define(Type.Ack, [
+    { key: "cmdId", type: F.STRING, rule: "optional" },
+    { key: "ok", type: F.BOOL, rule: "optional" },
+    { key: "error", type: F.STRING, rule: "optional" },
+    { key: "alreadyGone", type: F.BOOL, rule: "optional" },
+    { key: "room", type: Type.AckRoom, rule: "optional" },
+    // APPEND-ONLY (task 003): the room-already-exists signal must stay LAST so
+    // existing tags are unmoved (see the append-only tag rule in the file header).
+    { key: "exists", type: F.BOOL, rule: "optional" }
+  ]);
+  serializer = s;
+  return s;
+}
+function labelsToList(labels) {
+  return Object.entries(labels ?? {}).map(([key, value]) => ({ key, value }));
+}
+function capacityToMessage(capacity) {
+  return {
+    maxConnections: capacity?.maxConnections ?? null,
+    maxRooms: capacity?.maxRooms ?? null
+  };
+}
+function stateToMessage(p) {
+  if (!p.full) {
+    return { reqId: p.reqId, full: false, seq: p.seq, hash: p.hash };
+  }
+  return {
+    reqId: p.reqId,
+    full: true,
+    seq: p.seq,
+    hash: p.hash,
+    name: p.name,
+    processUid: p.processUid,
+    agentVersion: p.agentVersion,
+    protocolVersion: p.protocolVersion,
+    endpointUrl: p.endpointUrl,
+    labels: labelsToList(p.labels),
+    capacity: capacityToMessage(p.capacity),
+    autoCreate: p.autoCreate,
+    roomTypes: p.roomTypes ?? [],
+    rooms: (p.rooms ?? []).map((r) => ({
+      id: r.id,
+      type: r.type,
+      connections: r.connections,
+      origin: r.origin
+    })),
+    status: p.status
+  };
+}
+function toMessage(topic, payload) {
+  switch (topic) {
+    case Topics.state:
+      return stateToMessage(payload);
+    case Topics.poll: {
+      const p = payload;
+      const msg = { reqId: p.reqId, status: p.status };
+      if (p.knownHash !== null && p.knownHash !== void 0) {
+        msg.knownHash = p.knownHash;
+      }
+      return msg;
+    }
+    default:
+      return payload;
+  }
+}
+function encodeFrame(topic, payload) {
+  const type = TOPIC_TYPE[topic];
+  if (type === void 0) {
+    throw new Error(`fleet wire: no message type for topic=${topic}`);
+  }
+  const body = getSerializer().encode(type, toMessage(topic, payload));
+  const frame = new Uint8Array(HEADER_BYTES + body.length);
+  frame[0] = WIRE_MAJOR;
+  frame[1] = WIRE_MINOR;
+  frame.set(body, HEADER_BYTES);
+  return frame;
+}
+
+// src/agent/Snapshot.ts
+var MAX_SNAPSHOT_BYTES = 4 * 1024 * 1024;
+var WARN_RATIO = 0.5;
+var ERROR_RATIO = 0.9;
+var MIN_CORE_VERSION = "6.1.0";
+function generateProcessUid() {
+  return "p_" + (0, import_node_crypto2.randomBytes)(12).toString("hex");
+}
+var Snapshot = class {
+  /** Stable per-process id (§6) — constant across reconnects. */
+  processUid;
+  rivalis;
+  logger;
+  name;
+  endpointUrl;
+  labels;
+  capacity;
+  autoCreate;
+  agentVersion;
+  protocolVersion;
+  /** Room ids created in response to `fleet/cmd` → stamped `origin: 'fleet'`. */
+  fleetOrigins = /* @__PURE__ */ new Set();
+  /** Agent owns `status` (§7); flipped via `setStatus`. */
+  statusValue;
+  /** Per-connection monotonic frame counter — defensive hardening only (§7). */
+  seq = 0;
+  constructor(rivalis, options, logger) {
+    this.assertCoreSupport(rivalis);
+    this.rivalis = rivalis;
+    this.logger = logger ?? rivalis.logging?.getLogger?.("fleet:agent") ?? NOOP_LOGGER;
+    this.name = options.name;
+    this.endpointUrl = options.endpointUrl;
+    this.labels = options.labels ?? {};
+    this.capacity = {
+      maxConnections: options.capacity?.maxConnections ?? null,
+      maxRooms: options.capacity?.maxRooms ?? null
+    };
+    this.autoCreate = options.autoCreate ?? true;
+    this.agentVersion = options.agentVersion ?? packageVersion();
+    this.protocolVersion = options.protocolVersion ?? PROTOCOL_VERSION;
+    this.processUid = options.processUid ?? generateProcessUid();
+    this.statusValue = options.status ?? "active";
+  }
+  get status() {
+    return this.statusValue;
+  }
+  /** Flip the agent-owned status (§7). The next snapshot carries the new value. */
+  setStatus(status) {
+    this.statusValue = status;
+  }
+  /** Stamp a room as fleet-created (`origin: 'fleet'`). Called on a `fleet/cmd` create. */
+  markFleetOrigin(roomId) {
+    this.fleetOrigins.add(roomId);
+  }
+  /** Drop provenance for a destroyed room so a future id reuse is not mis-stamped. */
+  forgetRoom(roomId) {
+    this.fleetOrigins.delete(roomId);
+  }
+  /**
+   * New connection (reconnect): reset the `seq` counter. The reconnect assigns a
+   * fresh `instanceId`, so the orchestrator holds no prior hash and its first poll
+   * carries `knownHash: null` → the next reply is always a full snapshot (§7).
+   */
+  resetConnection() {
+    this.seq = 0;
+  }
+  /**
+   * Rebuild the full semantic snapshot from live core state and hash it. Pure:
+   * no `seq`, no size guard, no dedup-state mutation — used for hash inspection
+   * and as the basis for {@link pollReply}.
+   */
+  rebuild() {
+    const content = this.buildContent();
+    return { content, hash: hash64(content) };
+  }
+  /**
+   * Build a `fleet/state` reply to an orchestrator `fleet/poll` (§7, task 011).
+   * The orchestrator drives the dedup: a FULL snapshot when the rebuilt hash
+   * differs from the poll's `knownHash` (or `knownHash` is null — no prior state /
+   * forced full), a hash-only reply otherwise. Always advances `seq`.
+   */
+  pollReply(reqId, knownHash) {
+    const { content, hash } = this.rebuild();
+    const seq = this.nextSeq();
+    if (knownHash !== null && hash === knownHash) {
+      const payload2 = { reqId, full: false, seq, hash, ...content };
+      return { kind: "state", full: false, hash, encodedBytes: 0, payload: payload2 };
+    }
+    const payload = { reqId, full: true, seq, hash, ...content };
+    const encodedBytes = encodeFrame(Topics.state, payload).length;
+    this.checkSize(encodedBytes, content.rooms.length);
+    return { kind: "state", full: true, hash, encodedBytes, payload };
+  }
+  nextSeq() {
+    this.seq += 1;
+    return this.seq;
+  }
+  buildContent() {
+    const manager = this.rivalis.rooms;
+    const roomTypes = [...manager.definitions()].sort();
+    const rooms = [];
+    for (const id of manager.keys()) {
+      const room = manager.get(id);
+      if (room === null) {
+        continue;
+      }
+      if (typeof room.type !== "string") {
+        throw new Error(this.coreSupportError(`room id=(${id}) has no string \`type\``));
+      }
+      rooms.push({
+        id,
+        type: room.type,
+        connections: room.actorCount,
+        origin: this.fleetOrigins.has(id) ? "fleet" : "local"
+      });
+    }
+    rooms.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    return {
+      name: this.name,
+      processUid: this.processUid,
+      agentVersion: this.agentVersion,
+      protocolVersion: this.protocolVersion,
+      endpointUrl: this.endpointUrl,
+      labels: this.labels,
+      capacity: this.capacity,
+      autoCreate: this.autoCreate,
+      roomTypes,
+      rooms,
+      status: this.statusValue
+    };
+  }
+  checkSize(bytes, roomCount) {
+    const pct = Math.round(bytes / MAX_SNAPSHOT_BYTES * 100);
+    if (bytes >= MAX_SNAPSHOT_BYTES * ERROR_RATIO) {
+      this.logger.error(
+        `fleet snapshot at ${pct}% of the 4 MiB transport frame limit (${bytes} bytes, ${roomCount} rooms). An oversized snapshot is terminated by the transport, which causes a permanent reconnect loop. Remediation: host fewer rooms per instance, raise the orchestrator's WSTransport.maxPayload, or split the fleet across more instances (chunked sync is roadmap \xA716).`
+      );
+    } else if (bytes >= MAX_SNAPSHOT_BYTES * WARN_RATIO) {
+      this.logger.warning(
+        `fleet snapshot at ${pct}% of the 4 MiB transport frame limit (${bytes} bytes, ${roomCount} rooms) \u2014 approaching the size guard.`
+      );
+    }
+  }
+  /**
+   * Feature-detect the §4 core additions and throw an actionable, version-naming
+   * error when they are absent — a clean failure at startup instead of
+   * `undefined` types in snapshots at runtime. `Room.type` can only be checked
+   * against rooms that already exist; with zero rooms the `definitions()` gate
+   * is the primary guard (and `buildContent` re-checks each room defensively).
+   */
+  assertCoreSupport(rivalis) {
+    const manager = rivalis?.rooms;
+    if (manager === void 0 || manager === null) {
+      throw new Error(this.coreSupportError("rivalis.rooms is not available"));
+    }
+    if (typeof manager.definitions !== "function") {
+      throw new Error(this.coreSupportError("rivalis.rooms.definitions() is not available"));
+    }
+    if (typeof manager.keys !== "function" || typeof manager.get !== "function") {
+      throw new Error(this.coreSupportError("rivalis.rooms.keys()/get() are not available"));
+    }
+    for (const id of manager.keys()) {
+      const room = manager.get(id);
+      if (room !== null && typeof room.type !== "string") {
+        throw new Error(this.coreSupportError(`Room.type is not available (room id=(${id}) has no string \`type\`)`));
+      }
+    }
+  }
+  coreSupportError(detail) {
+    return `@rivalis/fleet requires @rivalis/core >= ${MIN_CORE_VERSION}: ${detail}. Upgrade @rivalis/core to >= ${MIN_CORE_VERSION} (the \xA74 additions: Room.type, RoomManager.definitions()).`;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_SNAPSHOT_BYTES,
+  Snapshot
+});

package/lib/canonical.js

@@ -0,0 +1,82 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/canonical.ts
+var canonical_exports = {};
+__export(canonical_exports, {
+  canonicalize: () => canonicalize,
+  hash64: () => hash64
+});
+module.exports = __toCommonJS(canonical_exports);
+var import_node_crypto = require("crypto");
+function canonicalize(value) {
+  return encode(value);
+}
+function encode(value) {
+  if (value === null) {
+    return "null";
+  }
+  const type = typeof value;
+  if (type === "string") {
+    return JSON.stringify(value);
+  }
+  if (type === "number") {
+    return Number.isFinite(value) ? String(value) : "null";
+  }
+  if (type === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (type === "bigint") {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((item) => encodeArrayItem(item));
+    return "[" + items.join(",") + "]";
+  }
+  if (type === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    const parts = [];
+    for (const key of keys) {
+      const child = obj[key];
+      if (isSkippable(child)) {
+        continue;
+      }
+      parts.push(JSON.stringify(key) + ":" + encode(child));
+    }
+    return "{" + parts.join(",") + "}";
+  }
+  return "null";
+}
+function encodeArrayItem(item) {
+  return isSkippable(item) ? "null" : encode(item);
+}
+function isSkippable(value) {
+  const type = typeof value;
+  return value === void 0 || type === "function" || type === "symbol";
+}
+function hash64(value) {
+  const digest = (0, import_node_crypto.createHash)("sha256").update(canonicalize(value)).digest();
+  return digest.subarray(0, 8).toString("hex");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  canonicalize,
+  hash64
+});