@xanots/sdk 0.0.1

package/dist/chunk-GNPVYOPB.js

@@ -0,0 +1,17 @@
+// src/util/atomic-write.ts
+import { writeFileSync, renameSync, rmSync } from "fs";
+function atomicWrite(path, contents, opts) {
+  const tmp = `${path}.tmp-${process.pid}`;
+  try {
+    writeFileSync(tmp, contents, opts?.mode !== void 0 ? { encoding: "utf8", mode: opts.mode } : "utf8");
+    renameSync(tmp, path);
+  } catch (err) {
+    rmSync(tmp, { force: true });
+    throw err;
+  }
+}
+
+export {
+  atomicWrite
+};
+//# sourceMappingURL=chunk-GNPVYOPB.js.map

package/dist/chunk-HJPTWBLH.js

@@ -0,0 +1,38 @@
+import {
+  atomicWrite
+} from "./chunk-GNPVYOPB.js";
+import {
+  parseLock,
+  serializeLock
+} from "./chunk-4HT3BNZ7.js";
+
+// src/lock/io.ts
+import { readFileSync, existsSync } from "fs";
+function readLockFile(path) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (err) {
+    throw new Error(
+      `Cannot read lock file ${path}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return parseLock(text, path);
+}
+function writeLockFile(path, lock) {
+  const next = serializeLock(lock);
+  if (existsSync(path)) {
+    try {
+      if (readFileSync(path, "utf8") === next) return false;
+    } catch {
+    }
+  }
+  atomicWrite(path, next);
+  return true;
+}
+
+export {
+  readLockFile,
+  writeLockFile
+};
+//# sourceMappingURL=chunk-HJPTWBLH.js.map

package/dist/chunk-IZW6MK3U.js

@@ -0,0 +1,248 @@
+import {
+  detail,
+  error,
+  stderrStyle,
+  stdoutStyle
+} from "./chunk-EZG76F7R.js";
+import {
+  COMMANDS,
+  FLAGS,
+  GLOBAL_FLAGS,
+  HELP_GROUP_ORDER,
+  flagKey,
+  flagNames,
+  flagSummary,
+  flagValues,
+  getCommand,
+  getSubcommand,
+  liveCommandNames,
+  liveSubcommandNames,
+  renderArgs,
+  suggest
+} from "./chunk-YYRDLFSJ.js";
+
+// src/emit/help.ts
+function table(rows, s, indent = "  ", fixedWidth) {
+  const width = fixedWidth ?? Math.max(0, ...rows.map(([name]) => name.length));
+  return rows.map(([name, desc]) => `${indent}${s.cyan(name.padEnd(width))}  ${s.dim(desc)}`);
+}
+function renderFlagSpec(ref) {
+  const spec = FLAGS[flagKey(ref)].spec;
+  const values = flagValues(ref);
+  if (values === void 0 || typeof ref === "string" || ref.values === void 0) return spec;
+  return spec.replace(/<[^>]*>/, `<${values.join("|")}>`);
+}
+function flagSection(flags, s) {
+  if (!flags || flags.length === 0) return [];
+  const rows = flags.filter((ref) => Object.hasOwn(FLAGS, flagKey(ref))).map((ref) => [renderFlagSpec(ref), flagSummary(ref)]);
+  if (rows.length === 0) return [];
+  return ["", s.bold("Flags"), ...table(rows, s)];
+}
+function argSection(args, s) {
+  const rows = (args ?? []).filter((a) => a.values !== void 0 && a.values.length > 0).map((a) => [`<${a.name}>`, a.values.join(", ")]);
+  return rows.length === 0 ? [] : ["", s.bold("Arguments"), ...table(rows, s)];
+}
+function exampleSection(example, s) {
+  return example ? ["", s.bold("Example"), `  ${s.dim(example)}`] : [];
+}
+function globalFlagRows() {
+  return GLOBAL_FLAGS.map((key) => [FLAGS[key].spec, FLAGS[key].summary]);
+}
+function renderGlobalHelp(s = stdoutStyle(), version = "") {
+  const byGroup = /* @__PURE__ */ new Map();
+  const push = (group, row) => {
+    const rows = byGroup.get(group) ?? [];
+    rows.push(row);
+    byGroup.set(group, rows);
+  };
+  for (const [name, spec] of Object.entries(COMMANDS)) {
+    if (spec.removed === void 0 && spec.aliasOf === void 0) push(spec.group, [spec.display, spec.summary]);
+    for (const sub of Object.values(spec.subcommands ?? {})) {
+      if (sub.group === void 0 || sub.removed !== void 0) continue;
+      push(sub.group, [sub.display ?? `${name} ${sub.summary}`, sub.groupSummary ?? sub.summary]);
+    }
+  }
+  const width = Math.max(0, ...[...byGroup.values()].flat().map(([n]) => n.length));
+  const lines = [
+    `${s.bold("xanots")}${version ? ` ${s.dim(`v${version}`)}` : ""} \u2014 the AI-first SDK & CLI for Xano backends`,
+    "",
+    `${s.dim("Usage:")} xanots ${s.cyan("<command>")} ${s.dim("[options]")}`
+  ];
+  for (const group of HELP_GROUP_ORDER) {
+    const rows = byGroup.get(group);
+    if (!rows || rows.length === 0) continue;
+    lines.push("", s.bold(group), ...table(rows, s, "  ", width));
+  }
+  lines.push("", s.bold("Global flags"), ...table(globalFlagRows(), s, "  ", width));
+  lines.push(
+    "",
+    s.dim("Run `xanots <command> --help` for a command's arguments and flags."),
+    s.dim("Docs: https://www.npmjs.com/package/@xanots/sdk")
+  );
+  return lines.join("\n") + "\n";
+}
+function renderCommandHelp(command, s = stdoutStyle()) {
+  const spec = getCommand(command);
+  if (!spec) return renderGlobalHelp(s);
+  const subs = liveSubcommandNames(command);
+  const usage = subs.length > 0 ? `xanots ${command} <subcommand> ${s.dim("[options]")}` : `xanots ${command}${renderArgs(spec.args) ? ` ${renderArgs(spec.args)}` : ""} ${s.dim("[options]")}`;
+  const lines = [`${s.bold(`xanots ${command}`)} \u2014 ${spec.summary}`, "", `${s.dim("Usage:")} ${usage}`];
+  if (subs.length > 0) {
+    const rows = subs.map((name) => {
+      const sub = getSubcommand(command, name);
+      const args = renderArgs(sub.args);
+      return [args ? `${name} ${args}` : name, sub.summary];
+    });
+    lines.push("", s.bold("Subcommands"), ...table(rows, s));
+  }
+  lines.push(...argSection(spec.args, s));
+  lines.push(...flagSection(spec.flags, s));
+  lines.push(...exampleSection(spec.example, s));
+  if (subs.length > 0) {
+    lines.push("", s.dim(`Run \`xanots ${command} <subcommand> --help\` for a subcommand's flags.`));
+  }
+  return lines.join("\n") + "\n";
+}
+function renderSubcommandHelp(command, sub, s = stdoutStyle()) {
+  const spec = getSubcommand(command, sub);
+  if (!spec || spec.removed !== void 0) return renderCommandHelp(command, s);
+  const args = renderArgs(spec.args);
+  const lines = [
+    `${s.bold(`xanots ${command} ${sub}`)} \u2014 ${spec.summary}`,
+    "",
+    `${s.dim("Usage:")} xanots ${command} ${sub}${args ? ` ${args}` : ""} ${s.dim("[options]")}`
+  ];
+  lines.push(...argSection(spec.args, s));
+  lines.push(...flagSection(spec.flags, s));
+  lines.push(...exampleSection(spec.example, s));
+  return lines.join("\n") + "\n";
+}
+function renderHelpFor(target, s, version = "") {
+  if (target?.command === void 0) return renderGlobalHelp(s, version);
+  if (target.subcommand !== void 0) return renderSubcommandHelp(target.command, target.subcommand, s);
+  return renderCommandHelp(target.command, s);
+}
+function indentBlock(text, indent = "  ") {
+  return text.split("\n").map((line) => line === "" ? line : indent + line).join("\n");
+}
+
+// src/emit/errors.ts
+var UsageError = class extends Error {
+  name = "UsageError";
+  /** The help block to print under the message. */
+  helpFor;
+  /** A closest-match hint (`Did you mean: details`), when one is close enough. */
+  suggestion;
+  constructor(message, opts = {}) {
+    super(message);
+    this.helpFor = opts.helpFor;
+    this.suggestion = opts.suggestion;
+  }
+};
+function isUsageError(err) {
+  return err instanceof UsageError;
+}
+function unknownCommand(name) {
+  const removed = getCommand(name)?.removed;
+  if (removed !== void 0) return new UsageError(removed, { helpFor: {} });
+  return new UsageError(`Unknown command "${name}".`, {
+    helpFor: {},
+    suggestion: suggest(name, liveCommandNames())
+  });
+}
+function unknownHelpTopic(name) {
+  return new UsageError(`\`xanots help\`: no help topic "${name}".`, {
+    helpFor: {},
+    suggestion: suggest(name, liveCommandNames())
+  });
+}
+function unknownSubcommand(command, sub) {
+  const removed = sub !== void 0 ? getSubcommand(command, sub)?.removed : void 0;
+  if (removed !== void 0) return new UsageError(removed, { helpFor: { command } });
+  const what = sub === void 0 || sub === "" ? "no subcommand given" : `unknown subcommand "${sub}"`;
+  return new UsageError(`\`xanots ${command}\`: ${what}.`, {
+    helpFor: { command },
+    suggestion: sub !== void 0 ? suggest(sub, liveSubcommandNames(command)) : void 0
+  });
+}
+function removedSubcommand(command, sub) {
+  const removed = getSubcommand(command, sub)?.removed;
+  return new UsageError(removed ?? `\`xanots ${command} ${sub}\` was removed.`, { helpFor: { command } });
+}
+function assertWritableDest(dest, command) {
+  if (dest !== "workspace") return;
+  throw new UsageError(
+    `\`xanots ${command} --dest workspace\` is not a thing \u2014 the only import path is a FULL REPLACE of the target workspace, so XanoTS never writes back to your real one. Deploy to a disposable environment instead (\`--dest ephemeral\` or \`--dest sandbox\`); to READ your real workspace, use \`xanots workspace codegen\`, or \`xanots test --dest workspace\` to run its tests.`,
+    { helpFor: { command } }
+  );
+}
+function unknownFlag(flags, target) {
+  const first = flags[0] ?? "";
+  const rest = flags.slice(1);
+  return new UsageError(
+    `Unknown flag ${first}${rest.length ? ` (also ${rest.join(", ")})` : ""}.`,
+    {
+      helpFor: target,
+      suggestion: suggestFlag(first)
+    }
+  );
+}
+function suggestFlag(flag) {
+  const typed = flag.replace(/^-+/, "").split("=")[0] ?? "";
+  const match = suggest(typed, flagNames());
+  return match === void 0 ? void 0 : `--${match}`;
+}
+function extraArguments(extras, target, max, attachedValueFlag) {
+  const where = target.subcommand ? `${target.command} ${target.subcommand}` : target.command;
+  const named = extras.map((e) => `"${e}"`).join(", ");
+  const noun = extras.length === 1 ? "argument" : "arguments";
+  const why = attachedValueFlag !== void 0 ? (
+    // `--lock` is the only flag with an attached-only value form, and its
+    // value is a path — spelled out here rather than reconstructed from the
+    // flag registry, whose `spec` strings are written for help, not reuse.
+    `\`${attachedValueFlag}\` takes its value attached: \`${attachedValueFlag}=<path>\`.`
+  ) : specFor(target)?.extraArgHint ?? (max === 0 ? `\`xanots ${where}\` takes no positional arguments.` : `\`xanots ${where}\` takes at most ${max}: ${renderArgs(specFor(target)?.args)}.`);
+  return new UsageError(`\`xanots ${where}\`: unexpected ${noun} ${named} \u2014 ${why}`, {
+    helpFor: target
+  });
+}
+function specFor(target) {
+  return target.subcommand !== void 0 ? getSubcommand(target.command, target.subcommand) : getCommand(target.command);
+}
+function missingArgument(arg, target) {
+  const where = target.subcommand ? `${target.command} ${target.subcommand}` : target.command;
+  return new UsageError(`\`xanots ${where}\`: missing required <${arg}>.`, { helpFor: target });
+}
+function reportFailure(err, version = "") {
+  const s = stderrStyle();
+  error(err instanceof Error ? err.message : String(err));
+  if (!isUsageError(err)) return;
+  if (err.suggestion !== void 0) {
+    process.stderr.write("\n");
+    detail(`Did you mean: ${s.cyan(err.suggestion)}`);
+  }
+  if (err.helpFor === void 0) return;
+  process.stderr.write("\n" + indentBlock(renderHelpFor(err.helpFor, s, version)));
+}
+function exitCodeOf(err) {
+  const code = err?.exitCode;
+  return typeof code === "number" && Number.isInteger(code) && code > 0 && code < 256 ? code : 1;
+}
+
+export {
+  renderGlobalHelp,
+  renderHelpFor,
+  indentBlock,
+  UsageError,
+  unknownCommand,
+  unknownHelpTopic,
+  unknownSubcommand,
+  removedSubcommand,
+  assertWritableDest,
+  unknownFlag,
+  extraArguments,
+  missingArgument,
+  reportFailure,
+  exitCodeOf
+};
+//# sourceMappingURL=chunk-IZW6MK3U.js.map

package/dist/chunk-LH6Z6KFV.js

@@ -0,0 +1,247 @@
+// src/values/mock.ts
+function isWrapped(e) {
+  return typeof e.tag !== "string";
+}
+function encodeMockMap(mock) {
+  const out = {};
+  for (const [testName, entry] of Object.entries(mock)) {
+    const wrapped = isWrapped(entry);
+    const value = wrapped ? entry.value : entry;
+    if (typeof value?.tag !== "string") {
+      throw new Error(
+        `mock for test "${testName}": expected a tagged value (\`c.*\`/\`ref\`/\u2026) or \`{ value, enabled }\`, got ${JSON.stringify(entry)}. A mock stores \`{value,tag,filters}\` copied off this argument, so a plain JS value encodes an empty mock that silently returns nothing when the test runs.`
+      );
+    }
+    out[testName] = {
+      value: value.value,
+      tag: value.tag,
+      filters: value.filters,
+      enabled: wrapped ? entry.enabled ?? true : true
+    };
+  }
+  return out;
+}
+
+// src/statements/statement.ts
+function annotate(stmt, a) {
+  if (a?.disabled !== void 0) stmt.disabled = a.disabled;
+  if (a?.description !== void 0) stmt.description = a.description;
+  if (a?.mock !== void 0) stmt.mocks = encodeMockMap(a.mock);
+  if (a?.asFilters !== void 0 && a.asFilters.length > 0) {
+    assertBindsAs(stmt, "asFilters");
+    stmt.output = { ...stmt.output ?? {}, filters: a.asFilters };
+  }
+  return stmt;
+}
+function assertBindsAs(stmt, option) {
+  if (stmt.as) return;
+  throw new Error(
+    `"${stmt.name}" binds no \`as\` variable, so \`${option}\` has nothing to filter. Bind the result with \`as\` first, or drop the option.`
+  );
+}
+function statements(...items) {
+  return items;
+}
+var RAW_ENVELOPE = /* @__PURE__ */ Symbol.for("xanots.statement.rawEnvelope");
+var registry = /* @__PURE__ */ new Map();
+function registerStatement(name, factory) {
+  registry.set(name, factory);
+}
+function isRegisteredStatement(name) {
+  return registry.has(name);
+}
+function getStatementFactory(name) {
+  const factory = registry.get(name);
+  if (!factory) {
+    throw new Error(
+      `Unknown statement "${name}". Registered: ${[...registry.keys()].join(", ") || "(none)"}`
+    );
+  }
+  return factory;
+}
+function fullInputEntry(raw) {
+  const e = raw ?? {};
+  return {
+    name: e.name,
+    value: e.value,
+    tag: e.tag,
+    filters: e.filters ?? [],
+    ignore: e.ignore ?? false,
+    expand: e.expand ?? false,
+    children: e.children ?? []
+  };
+}
+function encodeStatement(stmt) {
+  const rawEnvelope = stmt[RAW_ENVELOPE];
+  if (rawEnvelope !== void 0) return rawEnvelope;
+  if (!isRegisteredStatement(stmt.name)) {
+    throw new Error(
+      `Cannot encode unregistered statement "${stmt.name}". Registered: ${[...registry.keys()].join(", ") || "(none)"}`
+    );
+  }
+  const output = {
+    items: [],
+    filters: [],
+    customize: false,
+    ...stmt.output ?? {}
+  };
+  const sr = stmt.settings_registry;
+  const settings_registry = sr == null || Array.isArray(sr) && sr.length === 0 ? null : sr;
+  return {
+    as: stmt.as ?? "",
+    name: stmt.name,
+    _xsid: "",
+    addon: stmt.addon ?? [],
+    input: (stmt.input ?? []).map(fullInputEntry),
+    mocks: stmt.mocks ?? {},
+    output,
+    context: stmt.context,
+    runtime: stmt.runtime ?? null,
+    disabled: stmt.disabled ?? false,
+    description: stmt.description ?? "",
+    settings_registry
+  };
+}
+
+// src/responses/raw-response.ts
+var RAW_RESPONSE = /* @__PURE__ */ Symbol.for("xanots.response.rawEnvelope");
+var CANONICAL_KEYS = ["filters", "name", "tag", "value", "_xsid", "disabled"];
+function rawResponse(items) {
+  if (!Array.isArray(items)) {
+    throw new Error(
+      'rawResponse() expects an array of stored result[] entries, e.g. `[{ name: "", tag: "input", value: "x", filters: [] }]` \u2014 but received ' + (items === null ? "null" : typeof items)
+    );
+  }
+  const stored = items.map((item, i) => {
+    if (item == null || typeof item !== "object" || Array.isArray(item)) {
+      throw new Error(
+        `rawResponse() item ${i} is not a stored result envelope object \u2014 received ` + (item === null ? "null" : Array.isArray(item) ? "an array" : typeof item)
+      );
+    }
+    const out = {};
+    for (const key of CANONICAL_KEYS) {
+      if (Object.hasOwn(item, key)) out[key] = item[key];
+    }
+    for (const key of Object.keys(item)) {
+      if (!Object.hasOwn(out, key)) out[key] = item[key];
+    }
+    return out;
+  });
+  return { [RAW_RESPONSE]: stored };
+}
+function rawResponseItems(response) {
+  if (response == null || typeof response !== "object") return void 0;
+  return response[RAW_RESPONSE];
+}
+
+// src/fields/field.ts
+var INPUT_CONTEXT = {
+  customize: {},
+  marketItem: { id: 0, version: 0, guid: "" },
+  includeDescription: true
+};
+var COLUMN_CONTEXT = {
+  customize: {},
+  marketItem: { id: 0, version: 0, guid: "" },
+  includeDescription: true
+};
+function parseMethod(spec) {
+  if (typeof spec !== "string") return { name: spec.name, arg: spec.arg ?? [] };
+  const [name = spec, ...arg] = spec.split(":");
+  return { name, arg: arg.map((part) => isNumericArg(part) ? Number(part) : part) };
+}
+function isNumericArg(part) {
+  return part !== "" && String(Number(part)) === part;
+}
+function encodeMethods(methods) {
+  return (methods ?? []).map((spec) => {
+    const { name, arg } = parseMethod(spec);
+    return { name, disabled: false, arg };
+  });
+}
+function encodeCustomize(customize) {
+  const out = {};
+  for (const [name, node] of Object.entries(customize ?? {})) {
+    out[name] = {
+      hidden: node.hidden ?? false,
+      default: node.default !== void 0 ? String(node.default) : "",
+      methods: encodeMethods(node.methods),
+      required: node.required ?? false,
+      customize: encodeCustomize(node.customize)
+    };
+  }
+  return out;
+}
+var RAW_FIELD = /* @__PURE__ */ Symbol.for("xanots.field.rawEnvelope");
+function defaultEntry(options) {
+  if (options.noDefault === true) return {};
+  return { default: options.default !== void 0 ? String(options.default) : "" };
+}
+var NULLABLE_BY_DEFAULT = /* @__PURE__ */ new Set([
+  "blob",
+  "blob_img",
+  "blob_video",
+  "blob_audio",
+  "geo_point",
+  "geo_multipoint",
+  "geo_linestring",
+  "geo_multilinestring",
+  "geo_polygon",
+  "geo_multipolygon",
+  "uuid",
+  "vector"
+]);
+function defaultNullable(type) {
+  return NULLABLE_BY_DEFAULT.has(type);
+}
+function encodeField(name, type, options, ctx) {
+  const rawEnvelope = options?.[RAW_FIELD];
+  if (rawEnvelope !== void 0) return rawEnvelope;
+  const field = {
+    name,
+    type,
+    _xsid: "",
+    nullable: options.nullable ?? NULLABLE_BY_DEFAULT.has(type),
+    ...defaultEntry(options),
+    merge: options.merge ?? false,
+    hidden: options.hidden !== void 0 ? [...options.hidden] : [],
+    override: [],
+    customize: options.customize !== void 0 ? encodeCustomize(options.customize) : ctx.customize,
+    required: options.required ?? false,
+    values: options.values ?? [],
+    mode: options.mode ?? "",
+    format: options.format ?? "",
+    sensitive: options.sensitive ?? false,
+    list: options.list ?? { min: "", max: "" },
+    vector: options.vector ?? { size: 3 },
+    access: options.access ?? "public",
+    style: options.style ?? { type: options.array ? "list" : "single" },
+    children: (options.children ?? []).map((ch) => encodeField(ch.name, ch.type, ch, ctx)),
+    methods: encodeMethods(options.methods),
+    market_item: ctx.marketItem,
+    is_settings_registry: false
+  };
+  if (ctx.includeDescription) {
+    field.description = options.description ?? "";
+  }
+  return field;
+}
+
+export {
+  INPUT_CONTEXT,
+  COLUMN_CONTEXT,
+  RAW_FIELD,
+  defaultNullable,
+  encodeField,
+  encodeMockMap,
+  annotate,
+  statements,
+  RAW_ENVELOPE,
+  registerStatement,
+  isRegisteredStatement,
+  getStatementFactory,
+  encodeStatement,
+  rawResponse,
+  rawResponseItems
+};
+//# sourceMappingURL=chunk-LH6Z6KFV.js.map

package/dist/chunk-MZUI3JNX.js

@@ -0,0 +1,93 @@
+import {
+  c,
+  resp
+} from "./chunk-EMCAWMHC.js";
+
+// src/values/expect.ts
+var TEST_EXPECT_TYPES = [
+  "to_be_defined",
+  "to_be_empty",
+  "to_be_false",
+  "to_be_greater_than",
+  "to_be_in_the_future",
+  "to_be_in_the_past",
+  "to_be_less_than",
+  "to_be_null",
+  "to_be_true",
+  "to_be_within",
+  "to_contain",
+  "to_end_with",
+  "to_equal",
+  "to_match",
+  "to_not_be_defined",
+  "to_not_be_null",
+  "to_not_equal",
+  "to_start_with",
+  "to_throw"
+];
+function mk(type, ...vars) {
+  return { type, vars };
+}
+var expect = {
+  /** The subject is set (not undefined). */
+  to_be_defined: (subject) => mk("to_be_defined", subject),
+  /** The subject is undefined. */
+  to_not_be_defined: (subject) => mk("to_not_be_defined", subject),
+  /** The subject is empty — `""`, `[]`, `{}`, `0`, or null. */
+  to_be_empty: (subject) => mk("to_be_empty", subject),
+  /** The subject is `null`. */
+  to_be_null: (subject) => mk("to_be_null", subject),
+  /** The subject is not `null`. */
+  to_not_be_null: (subject) => mk("to_not_be_null", subject),
+  /** The subject is boolean true. */
+  to_be_true: (subject) => mk("to_be_true", subject),
+  /** The subject is boolean false. */
+  to_be_false: (subject) => mk("to_be_false", subject),
+  /** The subject is a timestamp later than now. */
+  to_be_in_the_future: (subject) => mk("to_be_in_the_future", subject),
+  /** The subject is a timestamp earlier than now. */
+  to_be_in_the_past: (subject) => mk("to_be_in_the_past", subject),
+  /** `subject === value`. */
+  to_equal: (subject, value) => mk("to_equal", subject, value),
+  /** `subject !== value`. */
+  to_not_equal: (subject, value) => mk("to_not_equal", subject, value),
+  /** `subject > value`, both read as numbers. */
+  to_be_greater_than: (subject, value) => mk("to_be_greater_than", subject, value),
+  /** `subject < value`, both read as numbers. */
+  to_be_less_than: (subject, value) => mk("to_be_less_than", subject, value),
+  /** A list subject contains the item; a text subject contains the substring. */
+  to_contain: (subject, item) => mk("to_contain", subject, item),
+  /** The subject, as text, starts with `prefix`. */
+  to_start_with: (subject, prefix) => mk("to_start_with", subject, prefix),
+  /** The subject, as text, ends with `suffix`. */
+  to_end_with: (subject, suffix) => mk("to_end_with", subject, suffix),
+  /**
+   * The subject matches a regular expression. `pattern` is a PCRE pattern
+   * INCLUDING its delimiters — build it with `c.regex(...)` rather than by hand;
+   * a bare `"^a"` is not a runnable pattern and the engine's match silently
+   * fails rather than erroring.
+   */
+  to_match: (subject, pattern) => mk("to_match", subject, pattern),
+  /**
+   * `min < subject < max`, both bounds EXCLUSIVE and all three read as numbers.
+   * A subject equal to either bound fails.
+   */
+  to_be_within: (subject, min, max) => mk("to_be_within", subject, min, max),
+  /**
+   * The run raised an error. Pass `exception` to require that text to appear in
+   * the error message (a case-insensitive substring, not an exact match);
+   * omit it to accept ANY error.
+   *
+   * Unlike every other matcher this one takes no subject: the thing under
+   * assertion is the run's failure, and the engine stores the response slot as
+   * a fixed first var. That is what the editor writes, and it is preserved so
+   * an authored test and a pulled one are the same bytes.
+   */
+  to_throw: (exception) => mk("to_throw", resp(), exception ?? c.text(""))
+};
+
+export {
+  TEST_EXPECT_TYPES,
+  expect
+};
+//# sourceMappingURL=chunk-MZUI3JNX.js.map