@xano/sdk 1.0.0

package/dist/chunk-N5GKCWE5.js

@@ -0,0 +1,367 @@
+import {
+  isTaggedValue
+} from "./chunk-OXA6PSZT.js";
+import {
+  resolveRef
+} from "./chunk-NZOWWHU5.js";
+import {
+  INPUT_CONTEXT,
+  encodeField
+} from "./chunk-TTEIYD5P.js";
+
+// src/fields/catalog.ts
+var DEFAULTABLE_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "int",
+  "decimal",
+  "enum",
+  "bool",
+  "email",
+  "json",
+  "date",
+  "epochms"
+]);
+var ACCESS_VALUES = /* @__PURE__ */ new Set(["public", "private", "internal"]);
+var FORMAT_VALUES = /* @__PURE__ */ new Set(["", "plaintext", "yaml", "html", "xml", "markdown"]);
+function assertEnumValues(values) {
+  if (Array.isArray(values) && values.every((v) => typeof v === "string" || typeof v === "number")) return;
+  throw new Error(`f.enum takes its values as a list of strings or numbers, FIRST: f.enum(["a", "b"], { default: "a" }) \u2014 got ${JSON.stringify(values)}.`);
+}
+function descriptor(type, options) {
+  if (options.format && type !== "text") {
+    throw new Error(`f: \`format\` is only valid on text fields, not "${type}".`);
+  }
+  if (options.format !== void 0 && !FORMAT_VALUES.has(options.format)) {
+    throw new Error(
+      `f: invalid text \`format\` "${options.format}"; valid: plaintext/yaml/html/xml/markdown.`
+    );
+  }
+  if (options.access !== void 0 && !ACCESS_VALUES.has(options.access)) {
+    throw new Error(
+      `f: invalid \`access\` "${options.access}"; valid: public/private/internal.`
+    );
+  }
+  if (options.default !== void 0 && options.default !== "" && !DEFAULTABLE_TYPES.has(type)) {
+    throw new Error(
+      `f: \`default\` is not supported on "${type}" fields (the engine drops it); valid on text/int/decimal/enum/bool/email/json/date/timestamp.`
+    );
+  }
+  if (options.noDefault === true && options.default !== void 0) {
+    throw new Error(
+      `f: \`noDefault\` and \`default\` are mutually exclusive on "${type}" fields \u2014 \`noDefault\` omits the key entirely, so there is no value to set.`
+    );
+  }
+  return { type, options };
+}
+function make(type, defaults) {
+  return (options = {}) => descriptor(type, { ...defaults, ...options });
+}
+function targetKeyType(table) {
+  if (typeof table === "string") return void 0;
+  const def = table;
+  if (def.idType === "int" || def.idType === "uuid") return def.idType;
+  if (def.schema === void 0 || def.schema === null) return void 0;
+  const idType = Array.isArray(def.schema) ? def.schema.find((col) => col?.name === "id")?.type : def.schema.id?.type;
+  if (idType === "uuid") return "uuid";
+  return idType === void 0 || idType === "int" ? "int" : void 0;
+}
+function toNestedFields(map) {
+  return Object.entries(map).map(([name, d]) => ({ name, type: d.type, ...d.options }));
+}
+var f = {
+  // --- scalars ---
+  text: make("text"),
+  int: make("int"),
+  decimal: make("decimal"),
+  bool: make("bool"),
+  uuid: make("uuid"),
+  date: make("date"),
+  email: make("email"),
+  /** Password field; defaults to `access:"internal"` (the engine's stored default). */
+  password: make("password", { access: "internal" }),
+  /**
+   * JSON column. Accepts an optional nested `children` schema — the structure the
+   * editor shows when a `json` field is expanded, and what a pulled workspace
+   * carries.
+   *
+   * `children` is spelled as an ARRAY of named, typed fields rather than the
+   * `FieldMap` {@link FieldCatalog.object} takes positionally. The two are not
+   * interchangeable: an object column's children are the column's own schema,
+   * while a json column's are a description of the shape stored inside it, which
+   * the engine persists in the order given. That order is part of the stored
+   * bytes, and a map does not preserve it.
+   *
+   * Without this there is no way to author a structured JSON column at all.
+   */
+  json(options = {}) {
+    return descriptor("json", { ...options });
+  },
+  /** Epoch-millisecond timestamp (authored as `timestamp`). */
+  timestamp: make("epochms"),
+  // --- file resources (authoring name → blob_* stored name) ---
+  /** Image file resource (stored `blob_img`). */
+  image: make("blob_img"),
+  /** Video file resource (stored `blob_video`). */
+  video: make("blob_video"),
+  /** Audio file resource (stored `blob_audio`). */
+  audio: make("blob_audio"),
+  /** Generic file attachment (stored `blob`). */
+  attachment: make("blob"),
+  // --- geo ---
+  geo: {
+    /** Value `{ type: "point", data: { lng, lat } }`. */
+    point: make("geo_point"),
+    /** Value `{ type: "points", data: [{ lng, lat }, …] }`. */
+    multipoint: make("geo_multipoint"),
+    /** Value `{ type: "path", data: [{ lng, lat }, …] }`. */
+    linestring: make("geo_linestring"),
+    /** Value `{ type: "paths", data: [[{ lng, lat }, …], …] }`. */
+    multilinestring: make("geo_multilinestring"),
+    /** Value `{ type: "poly", data: [{ lng, lat }, …] }` — the ring is closed for you. */
+    polygon: make("geo_polygon"),
+    /** Value `{ type: "polys", data: [[{ lng, lat }, …], …] }`. */
+    multipolygon: make("geo_multipolygon")
+  },
+  // --- composite (positional payload + options) ---
+  /**
+   * Enum field. `values` may be empty — that is an enum column added in the
+   * editor and not yet given its options, which the engine stores and which
+   * appears in the survey corpus. Refusing it made the SDK stricter than the
+   * engine and cost a real table its readable form.
+   *
+   * An empty `values` brands the column `never` — an enum permitting nothing can
+   * hold nothing. Note what that becomes downstream: `InferRow` surfaces the
+   * column as `undefined`, not `never`, so a read-time narrow written against
+   * `never` (`if (row.e === "x")`) is dead differently than it looks.
+   */
+  enum(values, options = {}) {
+    assertEnumValues(values);
+    return descriptor("enum", { ...options, values: [...values] });
+  },
+  /** Vector field; `size` (>= 1) is the embedding dimensionality. */
+  vector(size, options = {}) {
+    if (!Number.isInteger(size) || size < 1) {
+      throw new Error(`f.vector: size must be an integer >= 1, got ${size}.`);
+    }
+    return descriptor("vector", { ...options, vector: { size } });
+  },
+  /** Nested object field (stored `obj`); `children` is a named field map. */
+  object(children, options = {}) {
+    return descriptor("obj", { ...options, children: toNestedFields(children) });
+  },
+  /**
+   * Table-reference (foreign-key) field — the column holds the referenced
+   * table's primary key. The engine persists the link as a trailing `@` method
+   * carrying the target table's id (`{name:"@", arg:["dbo=<guid>"]}`); on import
+   * it parses that back into the column's `tableref_id`. The reference resolves to the
+   * table's deterministic guid via the shared cross-object resolver, so it
+   * agrees with the target table's payload `guid` with no shared registry.
+   *
+   * The column takes the target handle's key type (`idType`), else `int`; pass
+   * `{ type: "uuid" }` for a uuid-keyed table named by bare string. A reference
+   * column may only be `int` or `uuid` — the two valid primary-key types.
+   *
+   * @param table The referenced table (a `table()` def handle or its bare name).
+   *   For a **self-reference** (e.g. `tweets.reply_to → tweets`), the table's
+   *   `const` binding isn't assigned yet inside its own initializer — using the
+   *   handle throws a "used before declaration" error. Pass the **bare name**
+   *   instead: `f.tableRef("tweets", { type: "int" })`. Identity guids derive
+   *   from `(type, name)`, so the name form resolves to the same guid.
+   *
+   * Byte-verified whole-object against a persisted table readback: the `@`
+   * method carries
+   * `disabled:false`, sits last in `methods`, and its `dbo=` arg is the target
+   * table's payload guid.
+   *
+   * The engine asserts the referenced table's primary-key type matches
+   * (int↔int, uuid↔uuid). When the target is passed as a **def handle** its
+   * `idType` is in hand, so a mismatch throws here instead of surfacing as an
+   * import failure. The bare-name form (self-references) carries no schema —
+   * there is nothing to check against, and it is not guessed at.
+   */
+  tableRef(table, options = {}) {
+    const { type: given, methods = [], ...rest } = options;
+    const idType = targetKeyType(table);
+    const type = given ?? idType ?? "int";
+    if (idType !== void 0 && idType !== type) {
+      const name = typeof table === "string" ? `"${table}"` : table.name || "<unnamed>";
+      throw new Error(
+        `f.tableRef(${name}, { type: "${type}" }): that table's primary key is "${idType}". The engine requires a reference column to match the target's key type, so this fails at import. Drop \`type\` to take the key type from the handle.`
+      );
+    }
+    const guid = resolveRef("dbo", table);
+    return descriptor(type, {
+      ...rest,
+      methods: [...methods ?? [], { name: "@", arg: [`dbo=${guid}`] }]
+    });
+  }
+};
+
+// src/inputs/input.ts
+function makeInput(type) {
+  return (options = {}) => ({ type, options });
+}
+var input = {
+  // --- scalars ---
+  text: makeInput("text"),
+  int: makeInput("int"),
+  decimal: makeInput("decimal"),
+  bool: makeInput("bool"),
+  email: makeInput("email"),
+  /**
+   * Password input — hashes its value **when the input binds**, before your stack
+   * runs. This breaks the natural signup/login shape and is the single most common
+   * way to ship silently-broken auth:
+   * - **Login:** `s.security.check_password` receives the *already-hashed* submission
+   *   (a fresh random salt each request), compares it against the stored hash, and
+   *   never matches — so login always fails with a false "invalid password".
+   * - **Signup:** the value is hashed here at bind, so the `f.password` column then sees
+   *   an already-hashed `salt.hash` value and stores it as-is (the column's hash-on-write
+   *   skips a value already in that shape) — the plaintext never lands in the column.
+   *
+   * Recipe: use {@link input.text} (e.g. `input.text({ methods: ["min:6"] })`) for the
+   * password on **both** signup and login, let the `f.password` *column* hash on write,
+   * and pass the plaintext straight to `check_password`. See the auth recipe in the
+   * README. Reach for `input.password` only when you specifically want bind-time hashing
+   * and are not also comparing it with `check_password`.
+   */
+  password: makeInput("password"),
+  /**
+   * URL input — a `text` field that names the intent "this holds a URL". There
+   * is no native engine `url` type, and this does **not** by itself enforce an
+   * http(s) scheme: a `javascript:`/`data:` URL still type-checks and imports.
+   * When the value is security-relevant (e.g. a link that gets navigated to),
+   * reject bad input at the boundary in the stack with `s.precondition` — see
+   * the "validate input at the boundary" recipe in the README. Carries the same
+   * `TextMethod` options as {@link input.text}.
+   */
+  url: makeInput("text"),
+  uuid: makeInput("uuid"),
+  date: makeInput("date"),
+  /**
+   * Epoch-millisecond timestamp (stored `epochms`). A number binds as ms as-is —
+   * epoch SECONDS land in 1970 with no error — and an ISO-8601 string keeps its
+   * offset but drops fractional seconds. Send epoch ms for sub-second precision.
+   */
+  timestamp: makeInput("epochms"),
+  json: makeInput("json"),
+  /**
+   * Raw file **upload** (stored `file`) — the bytes as they arrive on the
+   * request (multipart, base64, or a fetched URI). Input-only: there is no
+   * `f.file` column, because an upload is not something a table holds.
+   *
+   * It is NOT a stored file resource and cannot be written to a file column
+   * directly. Store it first and write what you get back:
+   * `s.storage.create_image({ as: "img", value: inp("avatar") })`, then write
+   * `ref("img")` to an `f.image()` column. Use {@link input.image} and friends
+   * only when the caller already sends a stored file resource.
+   *
+   * Read the upload with `inp`, NOT `ref("input.avatar")`: `ref` is the `var`
+   * tag, so that spelling makes the engine look for a stack variable named
+   * `input` and fail the request with `Missing var entry: input`.
+   */
+  file: makeInput("file"),
+  /**
+   * **Database link** — one input that EXPANDS into one input per column of the
+   * linked table (stored `<tableGuid>_mvpschema`; XanoScript `dblink`). A table
+   * with three columns turns this single entry into three request inputs, so
+   * read them by their own column names: `inp("email")`, not `inp("user__")`.
+   * The expansion is live — adding a column to the table adds an input here.
+   *
+   * `hidden` is how you drop columns from that expansion (`["created_at", "id"]`)
+   * and is the common case in the wild, not an edge case. `merge: true` is what
+   * makes the engine expand rather than nest, so it is forced and cannot be
+   * unset — a dblink that does not merge is not a dblink.
+   *
+   * `customize` overrides individual expanded columns — `{ email: { required:
+   * true, methods: ["lower"] } }` — where `hidden` drops them wholesale. Both
+   * are read per column by the engine's expansion, and a column named in
+   * `customize` with `hidden: true` is dropped exactly as the outer list does it.
+   *
+   * Input-only: the engine refuses it as a column type, and a column linking a
+   * whole table would be a foreign key — use
+   * {@link f.tableRef} for that.
+   *
+   * By convention the editor names the entry after the table with a trailing
+   * `__` (`user__`), but the name is just the key in your `input:` map and any
+   * name round-trips.
+   */
+  dbLink(table, options = {}) {
+    return {
+      type: `${resolveRef("dbo", table)}_mvpschema`,
+      options: { ...options, merge: true }
+    };
+  },
+  // --- file resources / geo / vector / table refs (shared with the `f.*` catalog) ---
+  /** Image file input (stored `blob_img`). */
+  image: f.image,
+  /** Video file input (stored `blob_video`). */
+  video: f.video,
+  /** Audio file input (stored `blob_audio`). */
+  audio: f.audio,
+  /** Generic file-attachment input (stored `blob`). */
+  attachment: f.attachment,
+  /** Geo inputs: `input.geo.point()`, `.polygon()`, … (six geometry types). */
+  geo: f.geo,
+  /** Vector input; `size` (>= 1) is the embedding dimensionality. */
+  vector: f.vector,
+  /** Table-reference input — see {@link f.tableRef}; pass the table handle or bare name. */
+  tableRef: f.tableRef,
+  /**
+   * Enum input. `values` may be empty, mirroring {@link f.enum} — the two
+   * surfaces describe the same engine type, and one accepting what the other
+   * rejects is how they start disagreeing about what a workspace can hold.
+   */
+  enum(values, options = {}) {
+    return { type: "enum", options: { ...options, values: [...values] } };
+  },
+  /**
+   * Object input (stored `obj`) with typed, named children. `children` is a
+   * field map built from the same `f.*` catalog used for columns, e.g.
+   * `input.object({ name: f.text(), age: f.int() })`.
+   */
+  object(children, options = {}) {
+    return {
+      type: "obj",
+      options: { ...options, children: toNestedFields(children) }
+    };
+  },
+  /**
+   * List (array) input — wraps an element constructor, mirroring `Array<T>`:
+   * `input.list(input.text())`, `input.list(input.object({ id: f.int() }))`.
+   * The element's own options (e.g. its `methods`) are kept; list-level `options`
+   * (`required`, `nullable`, `description`, …) apply to the list field and win
+   * on conflict. The element's value type is preserved as the array element.
+   *
+   * A non-array value is NOT rejected: it binds as a one-item list, and a
+   * non-JSON string for an `input.object` element binds its children's defaults.
+   * A string starting with `[` is parsed as JSON without an element check. Mark
+   * an object child `required` or guard with `s.precondition` when the shape
+   * must hold.
+   */
+  list(element, options = {}) {
+    if (!element?.type) {
+      throw new Error("input.list: pass an element constructor, e.g. input.list(input.text()).");
+    }
+    return {
+      type: element.type,
+      options: { ...element.options, ...options, array: true }
+    };
+  }
+};
+function encodeInput(name, descriptor2) {
+  if (isTaggedValue(descriptor2)) {
+    throw new Error(
+      `input "${name}": got a value ref (inp("${descriptor2.value}"), tag "${descriptor2.tag}") where an input descriptor is required. An "input:" map wants a descriptor factory like input.text()/input.int()/input.enum([...]) \u2014 not the value ref inp(...). Reach for inp("${name}") only to READ this input inside a where/stack/value slot.`
+    );
+  }
+  return encodeField(name, descriptor2.type, descriptor2.options, INPUT_CONTEXT);
+}
+
+export {
+  toNestedFields,
+  f,
+  input,
+  encodeInput
+};
+//# sourceMappingURL=chunk-N5GKCWE5.js.map

package/dist/chunk-NA3PXMEF.js

@@ -0,0 +1,10 @@
+// src/util/sha256.ts
+import { createHash } from "crypto";
+function sha256Hex(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+
+export {
+  sha256Hex
+};
+//# sourceMappingURL=chunk-NA3PXMEF.js.map

package/dist/chunk-NAQDMEHV.js

@@ -0,0 +1,76 @@
+import {
+  credentialFileFlag,
+  recordedCredentialFile,
+  recordedCredentialPath,
+  resolveAuthFilePath
+} from "./chunk-XW6KISBB.js";
+import {
+  readEnvVar
+} from "./chunk-X2NL4KUO.js";
+import {
+  shellQuote
+} from "./chunk-5ZSO4T2G.js";
+
+// src/emit/context-flags.ts
+var ORIGIN_READ_ONLY_BY_REFRESH = "Drop `--origin` \u2014 only a XANO_REFRESH_TOKEN exchange reads it; a stored profile refreshes at the server recorded with it, and a meta API token never refreshes.";
+var ambient;
+function setHintContext(args) {
+  ambient = args === void 0 ? void 0 : { authFile: args.authFile, local: args.local, profile: args.profile, authHost: args.authHost };
+}
+function typedCredentialFlags() {
+  if (ambient === void 0) return {};
+  return {
+    ...ambient.authFile !== void 0 ? { authFile: ambient.authFile } : {},
+    ...ambient.local ? { local: true } : {},
+    ...ambient.authHost !== void 0 ? { authHost: ambient.authHost } : {},
+    ...ambient.profile !== void 0 ? { profile: ambient.profile } : {}
+  };
+}
+function credentialFileOf(args = ambient) {
+  if (args === void 0 || envCredentialResolves()) return void 0;
+  try {
+    return recordedCredentialFile(resolveAuthFilePath(args));
+  } catch {
+    return void 0;
+  }
+}
+function credentialFileFlagFor(recorded) {
+  return credentialFileFlag(recordedCredentialPath(recorded) ?? void 0);
+}
+function contextFlags(args = ambient, opts = {}) {
+  if (args === void 0 || opts.credentialStore !== true && envCredentialResolves()) return "";
+  let file;
+  try {
+    file = credentialFileFlag(resolveAuthFilePath(args));
+  } catch {
+    file = args.local ? " --local" : args.authFile !== void 0 ? ` --config ${shellQuote(args.authFile)}` : "";
+  }
+  const profile = args.profile !== void 0 && args.profile !== "" ? ` --profile ${shellQuote(args.profile)}` : "";
+  return `${profile}${file}`;
+}
+var CREDENTIAL_STORE_COMMANDS = /* @__PURE__ */ new Set(["login", "logout", "profile"]);
+function isCredentialStoreCommand(args) {
+  return args.command !== void 0 && CREDENTIAL_STORE_COMMANDS.has(args.command);
+}
+function envCredentialResolves() {
+  const meta = ["XANO_INSTANCE_URL", "XANO_WORKSPACE_ID", "XANO_META_TOKEN"].filter((v) => readEnvVar(v) !== void 0);
+  if (meta.length === 3) return true;
+  return meta.length === 0 && readEnvVar("XANO_REFRESH_TOKEN") !== void 0 && readEnvVar("XANO_CLIENT_ID") !== void 0;
+}
+var ENV_CREDENTIAL_VARS = "XANO_INSTANCE_URL, XANO_WORKSPACE_ID and XANO_META_TOKEN (or XANO_REFRESH_TOKEN)";
+function recordedByEnvCredential(record) {
+  return record?.credential === "environment";
+}
+
+export {
+  ORIGIN_READ_ONLY_BY_REFRESH,
+  setHintContext,
+  typedCredentialFlags,
+  credentialFileOf,
+  credentialFileFlagFor,
+  contextFlags,
+  isCredentialStoreCommand,
+  ENV_CREDENTIAL_VARS,
+  recordedByEnvCredential
+};
+//# sourceMappingURL=chunk-NAQDMEHV.js.map

package/dist/chunk-NWKXM5RD.js

@@ -0,0 +1,109 @@
+import {
+  appNamesByGuid,
+  lockNameForObject
+} from "./chunk-6MR5TI5V.js";
+
+// src/validate/kinds.ts
+var ROUND_TRIP_KINDS = [
+  { key: "dbo", fixtureDir: "tables" },
+  { key: "function", fixtureDir: "statements", runnable: true },
+  { key: "query", fixtureDir: "query" },
+  { key: "trigger", fixtureDir: "triggers" },
+  { key: "task", fixtureDir: "task" },
+  { key: "toolset", fixtureDir: "toolset" },
+  { key: "tool", fixtureDir: "toolset" },
+  // The other two MCP primitives an MCP server lists; their goldens share `mcp/`.
+  { key: "prompt", fixtureDir: "mcp" },
+  { key: "resource", fixtureDir: "mcp" },
+  { key: "middleware", fixtureDir: "middleware" },
+  { key: "addon", fixtureDir: "addon" },
+  { key: "workflow_test", fixtureDir: "workflow-test" },
+  { key: "knowledge", fixtureDir: "knowledge" },
+  // The realtime family: a server parents channels, a channel parents messages.
+  // All three are authored kinds carrying their own goldens under `realtime/`.
+  { key: "realtime_server", fixtureDir: "realtime" },
+  { key: "channel", fixtureDir: "realtime" },
+  { key: "message", fixtureDir: "realtime" },
+  { key: "microservice", fixtureDir: "microservice" },
+  // `app` is the API GROUP payload key — an authored container, not a deploy
+  // target. Its corpus dir does not exist yet; capture creates it on first
+  // promotion.
+  { key: "app", fixtureDir: "api-group" }
+];
+var FIXTURE_DIR_BY_KIND = new Map(ROUND_TRIP_KINDS.map((k) => [k.key, k.fixtureDir]));
+var RUNNABLE_KINDS = new Set(ROUND_TRIP_KINDS.filter((k) => k.runnable).map((k) => k.key));
+function fixtureDirForKind(key) {
+  return FIXTURE_DIR_BY_KIND.get(key);
+}
+function kindIsRunnable(key) {
+  return RUNNABLE_KINDS.has(key);
+}
+function strField(obj, key) {
+  const v = obj[key];
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+var nameKey = (obj) => strField(obj, "name");
+function identityKeyFor(kind, payload) {
+  if (kind !== "query") return nameKey;
+  const groupNames = appNamesByGuid(payload.app);
+  const guidById = /* @__PURE__ */ new Map();
+  for (const group of Array.isArray(payload.app) ? payload.app : []) {
+    if (group === null || typeof group !== "object") continue;
+    const guid = strField(group, "guid");
+    const id = group.id;
+    if (guid !== void 0 && id !== void 0) guidById.set(id, guid);
+  }
+  return (obj) => {
+    const name = nameKey(obj);
+    if (name === void 0) return void 0;
+    const ref = obj.app?.id;
+    const guid = guidById.get(ref);
+    const app = guid !== void 0 ? { id: guid } : obj.app;
+    return lockNameForObject("query", { name, verb: obj.verb, app }, groupNames);
+  };
+}
+function indexByIdentity(objects, keyOf = nameKey) {
+  const byGuid = /* @__PURE__ */ new Map();
+  const byKey = /* @__PURE__ */ new Map();
+  const duplicateGuids = /* @__PURE__ */ new Set();
+  const duplicateKeys = /* @__PURE__ */ new Set();
+  for (const obj of objects) {
+    const guid = strField(obj, "guid");
+    if (guid !== void 0) {
+      if (byGuid.has(guid)) duplicateGuids.add(guid);
+      else byGuid.set(guid, obj);
+    }
+    const key = keyOf(obj);
+    if (key !== void 0) {
+      if (byKey.has(key)) duplicateKeys.add(key);
+      else byKey.set(key, obj);
+    }
+  }
+  return { byGuid, byKey, duplicateGuids, duplicateKeys };
+}
+function resolveMatch(compiled, index, keyOf = nameKey) {
+  const guid = strField(compiled, "guid");
+  if (guid !== void 0 && index.byGuid.has(guid)) {
+    if (index.duplicateGuids.has(guid)) return { outcome: "ambiguous" };
+    return { outcome: "found", fetched: index.byGuid.get(guid) };
+  }
+  const key = keyOf(compiled);
+  if (key !== void 0 && index.byKey.has(key)) {
+    if (index.duplicateKeys.has(key)) return { outcome: "ambiguous" };
+    return { outcome: "found", fetched: index.byKey.get(key) };
+  }
+  return { outcome: "missing" };
+}
+function identityMatcher(kind, fetched, exportedPayload, compiledPayload) {
+  const index = indexByIdentity(fetched, identityKeyFor(kind, exportedPayload));
+  const compiledKey = identityKeyFor(kind, compiledPayload);
+  return (compiled) => resolveMatch(compiled, index, compiledKey);
+}
+
+export {
+  ROUND_TRIP_KINDS,
+  fixtureDirForKind,
+  kindIsRunnable,
+  identityMatcher
+};
+//# sourceMappingURL=chunk-NWKXM5RD.js.map