@xanots/sdk 0.0.1

package/dist/chunk-4HT3BNZ7.js

@@ -0,0 +1,675 @@
+// src/util/hash.ts
+var utf8 = new TextEncoder();
+function toBytes(input) {
+  return typeof input === "string" ? utf8.encode(input) : input;
+}
+function md5Bytes(input) {
+  const msg = toBytes(input);
+  const len = msg.length;
+  const withPad = (len + 8 >>> 6) + 1;
+  const words = new Int32Array(withPad * 16);
+  for (let i = 0; i < len; i++) {
+    const idx = i >> 2;
+    words[idx] = words[idx] | msg[i] << i % 4 * 8;
+  }
+  const padIdx = len >> 2;
+  words[padIdx] = words[padIdx] | 128 << len % 4 * 8;
+  words[words.length - 2] = len * 8;
+  let a = 1732584193, b = -271733879, c = -1732584194, d = 271733878;
+  const add = (x, y) => x + y | 0;
+  const rol = (n, s) => n << s | n >>> 32 - s;
+  const cmn = (q, a0, b0, x, s, t) => add(rol(add(add(a0, q), add(x, t)), s), b0);
+  const ff = (a0, b0, c0, d0, x, s, t) => cmn(b0 & c0 | ~b0 & d0, a0, b0, x, s, t);
+  const gg = (a0, b0, c0, d0, x, s, t) => cmn(b0 & d0 | c0 & ~d0, a0, b0, x, s, t);
+  const hh = (a0, b0, c0, d0, x, s, t) => cmn(b0 ^ c0 ^ d0, a0, b0, x, s, t);
+  const ii = (a0, b0, c0, d0, x, s, t) => cmn(c0 ^ (b0 | ~d0), a0, b0, x, s, t);
+  for (let i = 0; i < words.length; i += 16) {
+    const oa = a, ob = b, oc = c, od = d;
+    const w = (j) => words[i + j];
+    a = ff(a, b, c, d, w(0), 7, -680876936);
+    d = ff(d, a, b, c, w(1), 12, -389564586);
+    c = ff(c, d, a, b, w(2), 17, 606105819);
+    b = ff(b, c, d, a, w(3), 22, -1044525330);
+    a = ff(a, b, c, d, w(4), 7, -176418897);
+    d = ff(d, a, b, c, w(5), 12, 1200080426);
+    c = ff(c, d, a, b, w(6), 17, -1473231341);
+    b = ff(b, c, d, a, w(7), 22, -45705983);
+    a = ff(a, b, c, d, w(8), 7, 1770035416);
+    d = ff(d, a, b, c, w(9), 12, -1958414417);
+    c = ff(c, d, a, b, w(10), 17, -42063);
+    b = ff(b, c, d, a, w(11), 22, -1990404162);
+    a = ff(a, b, c, d, w(12), 7, 1804603682);
+    d = ff(d, a, b, c, w(13), 12, -40341101);
+    c = ff(c, d, a, b, w(14), 17, -1502002290);
+    b = ff(b, c, d, a, w(15), 22, 1236535329);
+    a = gg(a, b, c, d, w(1), 5, -165796510);
+    d = gg(d, a, b, c, w(6), 9, -1069501632);
+    c = gg(c, d, a, b, w(11), 14, 643717713);
+    b = gg(b, c, d, a, w(0), 20, -373897302);
+    a = gg(a, b, c, d, w(5), 5, -701558691);
+    d = gg(d, a, b, c, w(10), 9, 38016083);
+    c = gg(c, d, a, b, w(15), 14, -660478335);
+    b = gg(b, c, d, a, w(4), 20, -405537848);
+    a = gg(a, b, c, d, w(9), 5, 568446438);
+    d = gg(d, a, b, c, w(14), 9, -1019803690);
+    c = gg(c, d, a, b, w(3), 14, -187363961);
+    b = gg(b, c, d, a, w(8), 20, 1163531501);
+    a = gg(a, b, c, d, w(13), 5, -1444681467);
+    d = gg(d, a, b, c, w(2), 9, -51403784);
+    c = gg(c, d, a, b, w(7), 14, 1735328473);
+    b = gg(b, c, d, a, w(12), 20, -1926607734);
+    a = hh(a, b, c, d, w(5), 4, -378558);
+    d = hh(d, a, b, c, w(8), 11, -2022574463);
+    c = hh(c, d, a, b, w(11), 16, 1839030562);
+    b = hh(b, c, d, a, w(14), 23, -35309556);
+    a = hh(a, b, c, d, w(1), 4, -1530992060);
+    d = hh(d, a, b, c, w(4), 11, 1272893353);
+    c = hh(c, d, a, b, w(7), 16, -155497632);
+    b = hh(b, c, d, a, w(10), 23, -1094730640);
+    a = hh(a, b, c, d, w(13), 4, 681279174);
+    d = hh(d, a, b, c, w(0), 11, -358537222);
+    c = hh(c, d, a, b, w(3), 16, -722521979);
+    b = hh(b, c, d, a, w(6), 23, 76029189);
+    a = hh(a, b, c, d, w(9), 4, -640364487);
+    d = hh(d, a, b, c, w(12), 11, -421815835);
+    c = hh(c, d, a, b, w(15), 16, 530742520);
+    b = hh(b, c, d, a, w(2), 23, -995338651);
+    a = ii(a, b, c, d, w(0), 6, -198630844);
+    d = ii(d, a, b, c, w(7), 10, 1126891415);
+    c = ii(c, d, a, b, w(14), 15, -1416354905);
+    b = ii(b, c, d, a, w(5), 21, -57434055);
+    a = ii(a, b, c, d, w(12), 6, 1700485571);
+    d = ii(d, a, b, c, w(3), 10, -1894986606);
+    c = ii(c, d, a, b, w(10), 15, -1051523);
+    b = ii(b, c, d, a, w(1), 21, -2054922799);
+    a = ii(a, b, c, d, w(8), 6, 1873313359);
+    d = ii(d, a, b, c, w(15), 10, -30611744);
+    c = ii(c, d, a, b, w(6), 15, -1560198380);
+    b = ii(b, c, d, a, w(13), 21, 1309151649);
+    a = ii(a, b, c, d, w(4), 6, -145523070);
+    d = ii(d, a, b, c, w(11), 10, -1120210379);
+    c = ii(c, d, a, b, w(2), 15, 718787259);
+    b = ii(b, c, d, a, w(9), 21, -343485551);
+    a = add(a, oa);
+    b = add(b, ob);
+    c = add(c, oc);
+    d = add(d, od);
+  }
+  const out = new Uint8Array(16);
+  [a, b, c, d].forEach((word, wi) => {
+    for (let j = 0; j < 4; j++) out[wi * 4 + j] = word >>> j * 8 & 255;
+  });
+  return out;
+}
+function md5Hex(input) {
+  return toHex(md5Bytes(input));
+}
+function sha1Bytes(input) {
+  const msg = toBytes(input);
+  const len = msg.length;
+  const withLen = len + 9;
+  const blocks = Math.ceil(withLen / 64);
+  const total = blocks * 64;
+  const buf = new Uint8Array(total);
+  buf.set(msg);
+  buf[len] = 128;
+  const bitLen = len * 8;
+  buf[total - 4] = bitLen >>> 24 & 255;
+  buf[total - 3] = bitLen >>> 16 & 255;
+  buf[total - 2] = bitLen >>> 8 & 255;
+  buf[total - 1] = bitLen & 255;
+  let h0 = 1732584193, h1 = -271733879, h2 = -1732584194, h3 = 271733878, h4 = -1009589776;
+  const w = new Int32Array(80);
+  const rol = (n, s) => n << s | n >>> 32 - s;
+  for (let i = 0; i < total; i += 64) {
+    for (let j = 0; j < 16; j++) {
+      const k = i + j * 4;
+      w[j] = buf[k] << 24 | buf[k + 1] << 16 | buf[k + 2] << 8 | buf[k + 3];
+    }
+    for (let j = 16; j < 80; j++) w[j] = rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
+    let a = h0, b = h1, c = h2, d = h3, e = h4;
+    for (let j = 0; j < 80; j++) {
+      let f, k;
+      if (j < 20) {
+        f = b & c | ~b & d;
+        k = 1518500249;
+      } else if (j < 40) {
+        f = b ^ c ^ d;
+        k = 1859775393;
+      } else if (j < 60) {
+        f = b & c | b & d | c & d;
+        k = -1894007588;
+      } else {
+        f = b ^ c ^ d;
+        k = -899497514;
+      }
+      const t = rol(a, 5) + f + e + k + w[j] | 0;
+      e = d;
+      d = c;
+      c = rol(b, 30);
+      b = a;
+      a = t;
+    }
+    h0 = h0 + a | 0;
+    h1 = h1 + b | 0;
+    h2 = h2 + c | 0;
+    h3 = h3 + d | 0;
+    h4 = h4 + e | 0;
+  }
+  const out = new Uint8Array(20);
+  [h0, h1, h2, h3, h4].forEach((h, hi) => {
+    out[hi * 4] = h >>> 24 & 255;
+    out[hi * 4 + 1] = h >>> 16 & 255;
+    out[hi * 4 + 2] = h >>> 8 & 255;
+    out[hi * 4 + 3] = h & 255;
+  });
+  return out;
+}
+function toHex(bytes) {
+  let s = "";
+  for (const b of bytes) s += b.toString(16).padStart(2, "0");
+  return s;
+}
+function randomBytes(n) {
+  const out = new Uint8Array(n);
+  globalThis.crypto.getRandomValues(out);
+  return out;
+}
+
+// src/lock/store.ts
+var STORE_KEY = /* @__PURE__ */ Symbol.for("xanots.lock.overrides");
+function getStore() {
+  return globalThis[STORE_KEY];
+}
+function seedLockOverrides(lock) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const [key, entry] of Object.entries(lock.objects)) {
+    entries.set(key, { ...entry });
+  }
+  globalThis[STORE_KEY] = { entries };
+}
+function resetLockOverrides() {
+  delete globalThis[STORE_KEY];
+}
+function isLockSeeded() {
+  return getStore() !== void 0;
+}
+function getLockedGuid(key) {
+  return getStore()?.entries.get(key)?.guid;
+}
+function getLockedCanonical(key) {
+  return getStore()?.entries.get(key)?.canonical;
+}
+
+// src/refs/guid.ts
+var REFERENCEABLE_KIND_PAYLOAD_KEYS = {
+  function: "function",
+  query: "query",
+  tool: "tool",
+  // MCP servers and agents are distinct kinds that both persist as
+  // obj_type=toolset — they share the "toolset" migrate type, so both derive
+  // md5("toolset:"+name) and a same-name pair correctly collides. A trigger
+  // binds either by resolving against this same "toolset" migrate type.
+  mcp_server: "toolset",
+  agent: "toolset",
+  task: "task",
+  trigger: "trigger",
+  middleware: "middleware",
+  addon: "addon",
+  table: "dbo",
+  api_group: "app",
+  // Realtime: `realtime_server` -> `channel` -> `message`. Kind names match the
+  // engine's object types (the authoring factories carry the `realtime` prefix
+  // instead). Channel and message names are NOT workspace-unique, so their
+  // seeds are composed — see {@link realtimeChannelSeedName}.
+  realtime_server: "realtime_server",
+  channel: "channel",
+  message: "message",
+  // A container workload. Nothing in a stack resolves it by guid — `s.microservice.request`
+  // addresses one by NAME — but it is listed here because it is a top-level
+  // guid-tracked object, and the codegen index only places objects it recognises.
+  microservice: "microservice",
+  // An end-to-end test: a named stack of runs plus `expect` assertions. Kind
+  // name and migrate type are the same string, so the mapping is identity.
+  // Membership here is load-bearing twice over: `s.workflow_test.call` already
+  // resolves its target through this map, and `Xano#encodeOne` stamps a guid
+  // only for kinds in `REFERENCEABLE_KINDS` — and the engine REFUSES to export a
+  // workflow test that has none ("Missing workflow test guid."), a failure that
+  // surfaces only against a live instance.
+  workflow_test: "workflow_test"
+};
+var REFERENCEABLE_KINDS = new Set(Object.keys(REFERENCEABLE_KIND_PAYLOAD_KEYS));
+var SEED_SEP = "|";
+function seedPart(kind, label, value) {
+  if (!value) {
+    throw new Error(`realtime ${kind} identity: \`${label}\` is required to derive a stable guid.`);
+  }
+  if (value.includes(SEED_SEP)) {
+    throw new Error(
+      `realtime ${kind} identity: \`${label}\` must not contain "${SEED_SEP}" (got "${value}") \u2014 it separates the components of the guid seed, so a name carrying it could collide with a different object.`
+    );
+  }
+  return value;
+}
+function realtimeChannelSeedName(server, path) {
+  return [seedPart("channel", "server", server), seedPart("channel", "path", path)].join(SEED_SEP);
+}
+function realtimeMessageSeedName(server, channelPath, name) {
+  return [
+    seedPart("message", "server", server),
+    seedPart("message", "channel", channelPath),
+    seedPart("message", "name", name)
+  ].join(SEED_SEP);
+}
+function rawDeriveGuid(seed) {
+  return md5Hex(seed);
+}
+function deriveGuid(type, name) {
+  const seed = `${type}:${name}`;
+  const guid = getLockedGuid(seed) ?? rawDeriveGuid(seed);
+  SEEN_SEEDS.set(guid, seed);
+  return guid;
+}
+var SEEN_SEEDS = /* @__PURE__ */ new Map();
+function guidSeedHint(guid) {
+  return SEEN_SEEDS.get(guid);
+}
+function resolveRef(type, target) {
+  if (typeof target !== "string" && target.guid) {
+    if (target.name) SEEN_SEEDS.set(target.guid, `${type}:${target.name}`);
+    return target.guid;
+  }
+  const name = typeof target === "string" ? target : target.name;
+  if (!name) {
+    throw new Error(`Cannot resolve ${type} reference: target has no name or guid.`);
+  }
+  return deriveGuid(type, name);
+}
+
+// src/lock/lock.ts
+var LOCK_VERSION = 1;
+var WORKSPACE_KEY = "workspace";
+var RETIRED_KEYS = /* @__PURE__ */ new Map([
+  [
+    "workspace:realtime",
+    "the legacy workspace-level realtime block is no longer modelled; realtime servers and channels lock under their own keys"
+  ]
+]);
+var LOCK_PAYLOAD_KEYS = new Set(Object.values(REFERENCEABLE_KIND_PAYLOAD_KEYS));
+var CANONICAL_PAYLOAD_KEYS = /* @__PURE__ */ new Set(["app", "toolset", "realtime_server"]);
+var KIND_ALIASES = Object.fromEntries(
+  Object.entries(REFERENCEABLE_KIND_PAYLOAD_KEYS).filter(([name, key]) => name !== key)
+);
+function resolvePayloadKey(kindOrPayloadKey) {
+  if (LOCK_PAYLOAD_KEYS.has(kindOrPayloadKey)) return kindOrPayloadKey;
+  const key = REFERENCEABLE_KIND_PAYLOAD_KEYS[kindOrPayloadKey];
+  if (key === void 0) {
+    throw new Error(
+      `Unknown object kind "${kindOrPayloadKey}". Expected one of: ${[...LOCK_PAYLOAD_KEYS].join(", ")} (or the aliases ${Object.keys(KIND_ALIASES).join(", ")}).`
+    );
+  }
+  return key;
+}
+function lockKey(payloadKey, name) {
+  return `${payloadKey}:${name}`;
+}
+function emptyLock() {
+  return { version: LOCK_VERSION, objects: {} };
+}
+function findDuplicateRawKey(text) {
+  const stack = [];
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "{") {
+      stack.push(/* @__PURE__ */ new Set());
+      i++;
+    } else if (ch === "[") {
+      stack.push(null);
+      i++;
+    } else if (ch === "}" || ch === "]") {
+      stack.pop();
+      i++;
+    } else if (ch === '"') {
+      let j = i + 1;
+      let value = "";
+      while (j < text.length && text[j] !== '"') {
+        if (text[j] === "\\") {
+          value += text[j] + (text[j + 1] ?? "");
+          j += 2;
+        } else {
+          value += text[j];
+          j++;
+        }
+      }
+      j++;
+      let k = j;
+      while (k < text.length && /\s/.test(text[k])) k++;
+      if (text[k] === ":") {
+        const scope = stack[stack.length - 1];
+        if (scope) {
+          let decoded = value;
+          try {
+            decoded = JSON.parse(`"${value}"`);
+          } catch {
+          }
+          if (scope.has(decoded)) return decoded;
+          scope.add(decoded);
+        }
+      }
+      i = j;
+    } else {
+      i++;
+    }
+  }
+  return void 0;
+}
+function fail(path, message) {
+  throw new Error(`Invalid lock file ${path}: ${message}`);
+}
+function parseLock(text, path = "xano.lock") {
+  const dup = findDuplicateRawKey(text);
+  if (dup !== void 0) {
+    fail(
+      path,
+      `duplicate key "${dup}" in the raw text (likely a bad merge \u2014 JSON keeps only the last one silently). Resolve the duplicate and re-run.`
+    );
+  }
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch (err) {
+    fail(path, `unparseable JSON (${err instanceof Error ? err.message : String(err)}).`);
+  }
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    fail(path, "expected a top-level object.");
+  }
+  const obj = data;
+  if (obj.version !== LOCK_VERSION) {
+    fail(
+      path,
+      `unknown version ${JSON.stringify(obj.version)} (this XanoTS reads version ${LOCK_VERSION}). Upgrade XanoTS to a release that understands this lock format.`
+    );
+  }
+  if (!obj.objects || typeof obj.objects !== "object" || Array.isArray(obj.objects)) {
+    fail(path, "expected an `objects` map.");
+  }
+  return { version: LOCK_VERSION, objects: validateLockObjects(obj.objects, path) };
+}
+function validateLockModel(lock, label) {
+  validateLockObjects(lock.objects, label);
+}
+function validateLockObjects(raw, path) {
+  const objects = {};
+  const guidOwners = /* @__PURE__ */ new Map();
+  const canonicalOwners = /* @__PURE__ */ new Map();
+  for (const [key, entryRaw] of Object.entries(raw)) {
+    validateKey(key, path);
+    if (!entryRaw || typeof entryRaw !== "object" || Array.isArray(entryRaw)) {
+      fail(path, `entry "${key}" must be an object.`);
+    }
+    const { guid, canonical } = entryRaw;
+    if (guid !== void 0 && (typeof guid !== "string" || guid === "")) {
+      fail(path, `entry "${key}" has a non-string or empty \`guid\`.`);
+    }
+    if (canonical !== void 0 && (typeof canonical !== "string" || canonical === "")) {
+      fail(path, `entry "${key}" has a non-string or empty \`canonical\`.`);
+    }
+    if (guid === void 0 && canonical === void 0) {
+      fail(path, `entry "${key}" carries neither \`guid\` nor \`canonical\`.`);
+    }
+    const isWorkspaceKey = key === WORKSPACE_KEY;
+    if (isWorkspaceKey && guid !== void 0) {
+      fail(path, `entry "${key}" cannot carry a \`guid\` (workspace identities are canonical-only).`);
+    }
+    if (!isWorkspaceKey && canonical !== void 0) {
+      const prefix = key.slice(0, key.indexOf(":"));
+      if (!CANONICAL_PAYLOAD_KEYS.has(prefix)) {
+        fail(
+          path,
+          `entry "${key}" cannot carry a \`canonical\` \u2014 only ${[...CANONICAL_PAYLOAD_KEYS].join("/")} objects and the workspace key have one.`
+        );
+      }
+    }
+    if (typeof guid === "string") {
+      const owner = guidOwners.get(guid);
+      if (owner !== void 0) {
+        fail(path, `entries "${owner}" and "${key}" share the same guid (${guid}).`);
+      }
+      guidOwners.set(guid, key);
+    }
+    if (typeof canonical === "string") {
+      const owner = canonicalOwners.get(canonical);
+      if (owner !== void 0) {
+        fail(path, `entries "${owner}" and "${key}" share the same canonical (${canonical}).`);
+      }
+      canonicalOwners.set(canonical, key);
+    }
+    const entry = {};
+    if (typeof guid === "string") entry.guid = guid;
+    if (typeof canonical === "string") entry.canonical = canonical;
+    objects[key] = entry;
+  }
+  return objects;
+}
+function validateKey(key, path) {
+  if (key === WORKSPACE_KEY) return;
+  const retired = RETIRED_KEYS.get(key);
+  if (retired !== void 0) {
+    fail(path, `key "${key}" is retired \u2014 ${retired}. Remove the entry.`);
+  }
+  const idx = key.indexOf(":");
+  const prefix = idx === -1 ? key : key.slice(0, idx);
+  const name = idx === -1 ? "" : key.slice(idx + 1);
+  if (prefix === "workspace") {
+    fail(
+      path,
+      `key "${key}" is not a lockable workspace identity (only "${WORKSPACE_KEY}" exists).`
+    );
+  }
+  if (idx === -1 || name === "" || !LOCK_PAYLOAD_KEYS.has(prefix)) {
+    fail(
+      path,
+      `key "${key}" is not \`<payloadKey>:<name>\` with a known payload key (${[...LOCK_PAYLOAD_KEYS].join(", ")}).`
+    );
+  }
+}
+function serializeLock(lock) {
+  const objects = {};
+  for (const key of Object.keys(lock.objects).sort()) {
+    const src = lock.objects[key];
+    const entry = {};
+    if (src.guid !== void 0) entry.guid = src.guid;
+    if (src.canonical !== void 0) entry.canonical = src.canonical;
+    objects[key] = entry;
+  }
+  return JSON.stringify({ version: lock.version, objects }, null, 2) + "\n";
+}
+function mintCanonical() {
+  let bin = "";
+  for (const b of randomBytes(6)) bin += String.fromCharCode(b);
+  return btoa(bin).replace(/\+/g, "-").replace(/\//g, "_");
+}
+function createLockContext(lock = emptyLock()) {
+  return { lock, observed: {} };
+}
+function recordObserved(ctx, key, identity) {
+  const prior = ctx.observed[key];
+  if (prior?.guid !== void 0 && identity.guid !== void 0 && prior.guid !== identity.guid) {
+    throw new Error(
+      `Two exported objects collapse onto lock key "${key}" with different guids (${prior.guid} vs ${identity.guid}) \u2014 two same-kind objects sharing a name: a query verb pair pinning explicit guids, or a kind whose identity is composed from more than the name (a realtime channel is unique per server, a message per channel). The lock keys identity by (type, name) and cannot track both; rename one of the objects.`
+    );
+  }
+  const entry = ctx.lock.objects[key];
+  if (identity.guid !== void 0 && entry?.guid !== void 0 && identity.guid !== entry.guid) {
+    if (identity.guid === rawDeriveGuid(key)) {
+      throw new Error(
+        `"${key}" emitted its name-derived guid (${identity.guid}) but xano.lock pins ${entry.guid}. The lock overrides were not seeded before the workspace module loaded \u2014 programmatic exports must call seedLockOverrides(lock) before importing any def module (the CLI does this automatically).`
+      );
+    }
+    throw new Error(
+      `"${key}" has an explicit guid (${identity.guid}) that differs from its xano.lock entry (${entry.guid}), so references resolved through the lock would split from the object itself. Update the xano.lock entry to the explicit guid, or remove the explicit guid from code, then re-export.`
+    );
+  }
+  ctx.observed[key] = { ...ctx.observed[key], ...identity };
+}
+function renameLockEntry(lock, payloadKey, oldName, newName) {
+  const oldKey = lockKey(payloadKey, oldName);
+  const newKey = lockKey(payloadKey, newName);
+  const entry = lock.objects[oldKey];
+  if (entry === void 0) {
+    throw new Error(
+      `No lock entry "${oldKey}". \`lock rename\` moves an existing entry \u2014 check the kind and old name (kinds accept payload keys or the aliases table/api_group).`
+    );
+  }
+  const objects = { ...lock.objects };
+  let discardedNewcomer;
+  const existing = objects[newKey];
+  if (existing !== void 0) {
+    if (existing.guid !== rawDeriveGuid(newKey)) {
+      throw new Error(
+        `Lock entry "${newKey}" already exists and is not the fresh name-derivation (it pins ${existing.guid ?? "a canonical"}). Refusing to overwrite a real identity \u2014 resolve the conflict by hand-editing xano.lock if this is intended.`
+      );
+    }
+    discardedNewcomer = existing;
+  }
+  delete objects[oldKey];
+  objects[newKey] = { ...entry };
+  return { lock: { version: lock.version, objects }, discardedNewcomer };
+}
+function adoptFromBundle(lock, bundle, bundlePath) {
+  if (!bundle || typeof bundle !== "object" || Array.isArray(bundle)) {
+    throw new Error(`${bundlePath} is not a packageExport bundle (expected a top-level object).`);
+  }
+  const payload = bundle.payload;
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error(`${bundlePath} is not a packageExport bundle (missing \`payload\`).`);
+  }
+  const sections = payload;
+  const objects = { ...lock.objects };
+  for (const key of Object.keys(objects)) objects[key] = { ...objects[key] };
+  const added = [];
+  const changed = [];
+  let canonicalsSeen = false;
+  const applyEntry = (key, incoming) => {
+    const before = objects[key];
+    const after = { ...before, ...incoming };
+    if (before === void 0) {
+      objects[key] = after;
+      added.push(key);
+    } else if (before.guid !== after.guid || before.canonical !== after.canonical) {
+      changed.push({ key, before, after });
+      objects[key] = after;
+    }
+  };
+  for (const payloadKey of LOCK_PAYLOAD_KEYS) {
+    const arr = sections[payloadKey];
+    if (!Array.isArray(arr)) continue;
+    const namesSeen = /* @__PURE__ */ new Set();
+    for (const obj of arr) {
+      if (!obj || typeof obj !== "object") continue;
+      const o = obj;
+      if (typeof o.name !== "string" || typeof o.guid !== "string" || o.guid === "") continue;
+      if (namesSeen.has(o.name)) {
+        throw new Error(
+          `${bundlePath} contains two "${payloadKey}" objects named "${o.name}" (a query verb pair, most likely). The lock keys by (type, name) and cannot represent both \u2014 adoption aborted. Rename one of them engine-side so names are unique, then re-export and re-adopt.`
+        );
+      }
+      namesSeen.add(o.name);
+      const incoming = { guid: o.guid };
+      if (typeof o.canonical === "string" && o.canonical !== "") {
+        incoming.canonical = o.canonical;
+        canonicalsSeen = true;
+      }
+      applyEntry(lockKey(payloadKey, o.name), incoming);
+    }
+  }
+  const ws = sections["workspace"];
+  if (ws && typeof ws === "object" && !Array.isArray(ws)) {
+    const w = ws;
+    if (typeof w.canonical === "string" && w.canonical !== "") {
+      canonicalsSeen = true;
+      applyEntry(WORKSPACE_KEY, { canonical: w.canonical });
+    }
+  }
+  const vault = sections["vault"];
+  const vaultCount = Array.isArray(vault) ? vault.length : 0;
+  const merged = {
+    version: lock.version,
+    objects: validateLockObjects(objects, "the adopted lock")
+  };
+  return { lock: merged, added: added.sort(), changed, canonicalsSeen, vaultCount };
+}
+function mergeObserved(lock, observed) {
+  const objects = {};
+  for (const [key, identity] of Object.entries(observed)) {
+    objects[key] = { ...lock.objects[key], ...identity };
+  }
+  const liveGuids = new Set(Object.values(objects).map((e) => e.guid).filter(Boolean));
+  const liveCanonicals = new Set(
+    Object.values(objects).map((e) => e.canonical).filter(Boolean)
+  );
+  const orphans = [];
+  const dropped = [];
+  const cededCanonicals = [];
+  for (const [key, entry] of Object.entries(lock.objects)) {
+    if (key in objects) continue;
+    if (entry.guid !== void 0 && liveGuids.has(entry.guid)) {
+      dropped.push(key);
+      continue;
+    }
+    if (entry.canonical !== void 0 && liveCanonicals.has(entry.canonical)) {
+      const kept = { ...entry };
+      delete kept.canonical;
+      if (kept.guid === void 0) {
+        dropped.push(key);
+        continue;
+      }
+      objects[key] = kept;
+      orphans.push(key);
+      cededCanonicals.push(key);
+      continue;
+    }
+    objects[key] = entry;
+    orphans.push(key);
+  }
+  return {
+    lock: { version: lock.version, objects },
+    orphans: orphans.sort(),
+    dropped: dropped.sort(),
+    cededCanonicals: cededCanonicals.sort()
+  };
+}
+
+export {
+  sha1Bytes,
+  seedLockOverrides,
+  resetLockOverrides,
+  isLockSeeded,
+  getLockedGuid,
+  getLockedCanonical,
+  REFERENCEABLE_KIND_PAYLOAD_KEYS,
+  REFERENCEABLE_KINDS,
+  realtimeChannelSeedName,
+  realtimeMessageSeedName,
+  deriveGuid,
+  guidSeedHint,
+  resolveRef,
+  LOCK_VERSION,
+  WORKSPACE_KEY,
+  LOCK_PAYLOAD_KEYS,
+  CANONICAL_PAYLOAD_KEYS,
+  resolvePayloadKey,
+  lockKey,
+  emptyLock,
+  parseLock,
+  validateLockModel,
+  serializeLock,
+  mintCanonical,
+  createLockContext,
+  recordObserved,
+  renameLockEntry,
+  adoptFromBundle,
+  mergeObserved
+};
+//# sourceMappingURL=chunk-4HT3BNZ7.js.map

package/dist/chunk-4YMD2OOZ.js

@@ -0,0 +1,23 @@
+// src/function/define.ts
+function defineFunction(def) {
+  if (!def.name || typeof def.name !== "string") {
+    throw new Error("defineFunction: `name` is required and must be a non-empty string.");
+  }
+  return def;
+}
+
+// src/fields/file-url.ts
+function fileUrl(file, baseUrl) {
+  if (!file) return null;
+  if (typeof file.path === "string" && file.path !== "") {
+    const base = baseUrl.replace(/\/+$/, "");
+    return file.path.startsWith("/") ? base + file.path : `${base}/${file.path}`;
+  }
+  return typeof file.url === "string" && file.url !== "" ? file.url : null;
+}
+
+export {
+  defineFunction,
+  fileUrl
+};
+//# sourceMappingURL=chunk-4YMD2OOZ.js.map