@xanots/sdk 0.0.1

package/dist/cli.d.ts

@@ -0,0 +1,331 @@
+/**
+ * One archive member (structurally an `ArchiveEntry`): its in-archive path and
+ * the serialized signed `type:"content"` envelope written there.
+ */
+interface SeedContentFile {
+    /** `content/<table-guid>-<page>.json` (page 1-based, contiguous). */
+    name: string;
+    /** The serialized signed `type:"content"` envelope. */
+    content: string;
+}
+/** A seed value the schema says is not public, and where it came from. */
+interface NonPublicSeedValue {
+    table: string;
+    column: string;
+    value: string;
+    /**
+     * Whether a static build can actually be searched for this value.
+     *
+     * `false` for a value below {@link MIN_SCANNABLE_LENGTH}, and for a non-string
+     * one. Those are collected rather than dropped (issue #45): being too short to
+     * search for is not the same as being safe, and the author is the only one who
+     * can judge which it is. The scanner skips them; the deploy path reports them.
+     */
+    scannable: boolean;
+}
+
+interface ParsedArgs {
+    command: string | undefined;
+    /**
+     * The verb of a noun-verb command (`sandbox deploy`, `profile me`): here
+     * `command` is the noun and `subcommand` is the verb.
+     * Undefined for the single-token verbs (`compile`/`export`/`lock`/…).
+     */
+    subcommand: string | undefined;
+    file: string | undefined;
+    out: string | undefined;
+    /** All non-flag arguments after the command (file is positionals[0]). */
+    positionals: string[];
+    /** `--lock` / `--lock=<path>`: opt into creating a lock file. */
+    lock: boolean;
+    /** The `--lock=<path>` override (default: `xano.lock` beside the entry). */
+    lockPath: string | undefined;
+    /**
+     * `--entry=<path>`: the workspace entry the lock sits beside, for the `lock`
+     * subcommands that take no entry file of their own (`rename`/`adopt`).
+     *
+     * Distinct from `--lock`, which names the lock FILE directly. This names the
+     * entry and lets the default be DERIVED the way `export --lock` and `prune`
+     * derive it — so the caller still supplied the anchor and nothing is guessed.
+     */
+    entryPath: string | undefined;
+    /** `--frozen-lock`: hard-fail if the export would change the lock (CI). */
+    frozenLock: boolean;
+    /**
+     * `--strict`: promote every export/deploy WARNING to a hard failure — the
+     * build diagnostics (a `bulk.update` that zero-fills omitted columns, an
+     * `ignoreEmpty` that drops its predicate; issue #15) as well as the CLI's own
+     * preflights (unresolvable filter names, issue #106; a stale `--emit`
+     * manifest). Warnings print either way; `--strict` decides whether a printed
+     * one still ships.
+     */
+    strict: boolean;
+    /** `--yes`/`-y`: confirm destructive lock maintenance non-interactively. */
+    yes: boolean;
+    /** `push --bundle <path>`: upload an already-exported bundle instead of a file entry. */
+    bundle: string | undefined;
+    /** `--reset`: accepted but redundant — every deploy is a full replace now. */
+    reset: boolean;
+    /**
+     * `--dest`: which environment to address.
+     *
+     * The parser accepts all three because `test` reads all three. `workspace` is
+     * refused by the commands that WRITE (`deploy`, `release`) at dispatch, with
+     * the explanation — not here, where the message could only say "bad value"
+     * for something that is a deliberate product boundary rather than a typo.
+     */
+    dest: "sandbox" | "ephemeral" | "workspace" | undefined;
+    /** `test --kind unit|workflow`: narrow to one test family (default: both). */
+    kind: "unit" | "workflow" | undefined;
+    /** `test run-all --concurrency <n>`: how many tests to run at once (default 1). */
+    concurrency: number | undefined;
+    /** `deploy --test`: run the environment's tests after the deploy lands. */
+    test: boolean;
+    /** `deploy --expires-hours <n>`: ephemeral create-time TTL (1–72, default 1 server-side). */
+    expiresHours: number | undefined;
+    /**
+     * `routes --emit <path>`: write the generated route module there instead of
+     * printing the table. Plain data + one interpolator, importing nothing, so a
+     * frontend gets the typed path/verb contract without the SDK runtime.
+     */
+    emit: string | undefined;
+    /** `deploy --static <dir>`: archive this directory and deploy it to the sandbox's static host. */
+    static: string | undefined;
+    /**
+     * `deploy --static-env KEY=VALUE` (repeatable): public config baked into EVERY
+     * html document of the static build as `window.<KEY>` globals. The backend URL is
+     * wired in automatically as `window.XANO_HOST`; these override/extend it.
+     * Served to the browser verbatim — public values only, never secrets.
+     */
+    staticEnv: Record<string, string>;
+    /**
+     * `deploy --static-host <name>`: the static-host NAME to deploy the frontend
+     * to (default `default`). Give each app a distinct host so deploys don't share
+     * and overwrite one `default` host — the shared host is why a first post-deploy
+     * load can serve a *previous* app's cached `index.html`.
+     */
+    staticHost: string | undefined;
+    /**
+     * `deploy --static-routing spa|multipage`: override how the host resolves URLs
+     * within the build. Normally unset — the shape is inferred from the bundle.
+     * Set it for a single-document site that wants real 404s, or a bundle carrying
+     * a stray `.html` that should still route entirely client-side.
+     */
+    staticRouting: "spa" | "multipage" | undefined;
+    /** `--origin <origin>`: Xano control-plane OAuth host. Default: $XANO_ORIGIN, then https://app.xano.com. */
+    authHost: string | undefined;
+    /** `--config <path>`: explicit credential file. Default: $XANO_CONFIG, then ./.xano/auth.json. */
+    authFile: string | undefined;
+    /**
+     * `--local`: use the project-local `./.xano/auth.json` cache instead of the
+     * shared `~/.xanots/auth.json` one (the default). `login --local` writes
+     * there; other commands read it. Without `--local`, reads still prefer an
+     * existing project-local cache before falling back to the global one, so a
+     * `--local` project keeps working without repeating the flag.
+     */
+    local: boolean;
+    /**
+     * `ephemeral list --all-workspaces`: enumerate ephemeral tenants across every
+     * workspace on the instance, not just the token's parent workspace.
+     */
+    allWorkspaces: boolean;
+    /** `ephemeral impersonate --guest`/`-g`: mint a read-only guest session (browse only). */
+    guest: boolean;
+    /** `ephemeral impersonate --url-only`/`-u`: print the dashboard URL instead of opening a browser. */
+    urlOnly: boolean;
+    /** `marketplace details --prompt`: print the add-on's agent prompt alone, for piping. */
+    prompt: boolean;
+    /** `login --port <n>`: fixed loopback callback port (default: an ephemeral port). */
+    port: number | undefined;
+    /** `login --scope "<space list>"`: OAuth scopes to request (default: the built-in xano-cli set). */
+    scope: string | undefined;
+    /** `validate --runtime`: after import + round-trip, run each deployed function and report. */
+    runtime: boolean;
+    /** `validate --capture`: write each round-tripped function's fetched JSON (candidate fixtures). */
+    capture: boolean;
+    /** `validate --verbose`: print full diffs / raw engine detail instead of a projected summary. */
+    verbose: boolean;
+    /** `validate --instance <url>`: override XANO_VALIDATE_INSTANCE for this run. */
+    instance: string | undefined;
+    /** `sandbox export --format <json|multidoc>`: which artifact to emit (validated at parse time). */
+    format: "json" | "multidoc" | undefined;
+    /** `sandbox export --path <p>`: output location (`-` for stdout; a dir or a full file path). */
+    path: string | undefined;
+    /** `sandbox export --name <n>`: output basename override (default `sandbox`). Also the `init`/`codegen` app name (default: target dir basename). */
+    name: string | undefined;
+    /**
+     * `init`/`codegen` `--ai <preset>` (repeatable, comma-separated): AI-assistant instruction
+     * files to scaffold (`claude`/`codex`/`cursor`/`none`). Empty = prompt in a TTY,
+     * else write none. Validated in the init command, not at parse time.
+     */
+    ai: string[];
+    /**
+     * `init`/`codegen` `--framework <id>`: which frontend to scaffold
+     * (`react`/`svelte`). Undefined = prompt in a TTY, else the default.
+     * Validated in `frontend-presets.ts`, not at parse time.
+     */
+    framework: string | undefined;
+    /** `init`/`codegen` `--force`: scaffold into a non-empty target directory (overwrite our own files). */
+    force: boolean;
+    /** `init`/`codegen` `--no-install`: skip the post-scaffold `npm install`. For `codegen` this also means the round trip cannot be verified, since loading the tree needs its dependencies. */
+    noInstall: boolean;
+    /**
+     * `deploy --no-verify`: skip the post-deploy liveness checks. Everything is
+     * still deployed; XanoTS just doesn't wait to confirm it came up — neither
+     * that the edge is serving *this* static build (via `X-Xano-Canonical`) nor
+     * that the workspace's microservices reached a ready state. Useful for fast
+     * iterative deploys or when the deployed URL isn't reachable from the CLI host.
+     */
+    noVerify: boolean;
+    /**
+     * `deploy --require-microservices`: fail the deploy when a microservice has
+     * not reported ready by the end of the wait, not just when the engine says it
+     * is broken. A microservice the engine reports as FAILED already exits
+     * non-zero without this — the flag is what turns "still starting" into a
+     * failure too, which is the reading CI wants.
+     */
+    requireMicroservices: boolean;
+    /**
+     * `codegen --report <grouped|full|json>`: how the findings are rendered.
+     *
+     * `grouped` (the default) prints one line per distinct root cause with a count
+     * and a collapsed object list; `full` prints every site; `json` prints the
+     * findings as data for a CI gate to read. The findings themselves are the same
+     * set in all three — this chooses the rendering, never what is reported.
+     */
+    report: string | undefined;
+    /**
+     * `deploy --allow-seed-in-static`: publish a static build even when it
+     * contains seed values the schema declares non-public. The refusal exists
+     * because the alternative is serving them at a public URL; this is the escape
+     * hatch for a workspace whose seed is deliberately demo data.
+     */
+    allowSeedInStatic: boolean;
+    /**
+     * `release --dry-run`: print what the release WOULD change and exit without
+     * sending it. A destructive release previews anyway; this is how you preview
+     * one that isn't, or preview without being prompted.
+     */
+    dryRun: boolean;
+    /**
+     * `release --prune`: also delete objects in the target workspace that your
+     * project no longer defines. Without it a release only adds and updates, so
+     * something deleted from your code lingers in the workspace.
+     */
+    prune: boolean;
+    /**
+     * `release --reset-data`: empty every table the bundle carries before
+     * importing. Pair with `--seed` to reload the bundle's rows afterwards;
+     * alone it leaves the tables empty.
+     */
+    resetData: boolean;
+    /**
+     * `release --seed`: write the bundle's table rows into the workspace. Off by
+     * default, so a release cannot overwrite live data you did not ask it to.
+     */
+    seed: boolean;
+    /**
+     * `release --replace`: the OLD behavior — wipe the workspace (objects, table
+     * data and history) and import the bundle in its place, instead of merging.
+     * Named rather than implicit so it can never be reached by accident.
+     */
+    replace: boolean;
+    /**
+     * `--json`: force the machine-readable JSON on stdout even at a terminal.
+     * Absent, the format is inferred from stdout being a TTY. Read through
+     * `isMachineOutput` (output.ts) — never by re-checking `isTTY` at a call site.
+     */
+    json: boolean;
+    /**
+     * `deploy --open`: open the deployed URL in the default browser once it lands.
+     * Honors `XANO_NO_BROWSER` like every other launch, since it shares the same
+     * helper.
+     */
+    open: boolean;
+    /**
+     * Leading-dash tokens the parser doesn't recognize. They are collected HERE
+     * rather than falling into {@link positionals} so an unknown flag can never be
+     * resolved as the entry `<file>` — the issue #173 failure mode, where
+     * `xanots deploy --help` was imported as a module path and died in Node's
+     * loader with a message about a missing file named `--help`.
+     */
+    unknownFlags: string[];
+}
+declare function parseArgs(argv: string[]): ParsedArgs;
+/**
+ * A resolved help request: the deepest command path present, or the topic word
+ * that `xanots help <topic>` named and the registry does not know.
+ */
+interface HelpRequest {
+    command?: string;
+    subcommand?: string;
+    /** Set only for `xanots help <unknown>` — see {@link resolveHelpRequest}. */
+    unknownTopic?: string;
+}
+/**
+ * Resolve a help request straight from the RAW argv, before any flag parsing.
+ *
+ * Deliberately pre-parse: `parseArgs` throws on removed flags and malformed
+ * values, so resolving help afterwards would mean `xanots deploy --profile x
+ * --help` died on the flag error instead of printing the help the user asked
+ * for. Returns the deepest command path present (`{}` for global help), or
+ * undefined when no help was requested.
+ */
+declare function resolveHelpRequest(argv: string[]): HelpRequest | undefined;
+declare function loadDefault(file: string): Promise<unknown>;
+/**
+ * Resolve this package's version for `xanots version`. Walks up from the running
+ * module to the package root's `package.json` (`dist/cli.js` → `../`, the
+ * `src/emit/cli.ts` source → `../../`), matching on the package NAME so a stray
+ * ancestor `package.json` can't shadow it. Best-effort: returns `"unknown"` rather
+ * than throwing when it can't be located, since a version print must never fail.
+ */
+declare function readVersion(): string;
+/**
+ * Write the grouped command reference to STDOUT — help is requested output, not
+ * an error. The reference itself comes from the command registry via
+ * `help.ts`; nothing about the command surface is written down here.
+ */
+declare function printHelp(): void;
+declare function run(argv: string[]): Promise<void>;
+/**
+ * Resolve the lock path for an entry file: `--lock=<path>` wins, else
+ * `xano.lock` beside the entry (matching `export`/`compile` defaults).
+ */
+declare function resolveLockPath(args: ParsedArgs, file: string): string;
+/** A compiled bundle plus any seed `content/` entries (empty unless requested). */
+interface CompiledBundle {
+    bundle: string;
+    content: SeedContentFile[];
+    /**
+     * Names of tables that declared `seed` but whose rows were NOT built into
+     * `content` (i.e. `opts.seed` was false). Empty when `opts.seed` is true. Lets
+     * the `export` command warn that its artifact omits seed — so the CI pattern
+     * `export --out bundle.json` then `deploy --bundle bundle.json` doesn't drop
+     * seed silently (a `--bundle` deploy has no registry to resolve seed from).
+     */
+    omittedSeedTables: string[];
+    /**
+     * Seed values drawn from columns the schema declares non-public, for the
+     * `--static` publication guard. Empty unless seed was resolved.
+     */
+    nonPublicSeedValues: NonPublicSeedValue[];
+}
+/**
+ * Thin wrapper over {@link compileBundle} for the many callers that only need the
+ * bundle text (export, validate, sandbox-export). Seed content is not built here.
+ */
+declare function exportBundleJson(args: ParsedArgs): Promise<string>;
+/**
+ * Compile an entry file to its `packageExport` bundle, running the full lock
+ * pipeline (seed → export → write). With `opts.seed`, also resolve + validate the
+ * tables' seed rows into signed `content/` archive entries — done HERE, inside the
+ * same lock-seeded context as the export, so a seed file's `dbo` guid matches the
+ * table's guid in `workspace.json`. Only the deploy path passes `seed:true`, so a
+ * plain `export`/`validate` never resolves seed sources.
+ */
+declare function compileBundle(args: ParsedArgs, opts?: {
+    seed?: boolean;
+}): Promise<CompiledBundle>;
+
+export { type CompiledBundle, type HelpRequest, type ParsedArgs, compileBundle, exportBundleJson, loadDefault, parseArgs, printHelp, readVersion, resolveHelpRequest, resolveLockPath, run };

package/dist/cli.js

@@ -0,0 +1,33 @@
+import {
+  compileBundle,
+  exportBundleJson,
+  loadDefault,
+  parseArgs,
+  printHelp,
+  readVersion,
+  resolveHelpRequest,
+  resolveLockPath,
+  run
+} from "./chunk-YGPIY3WT.js";
+import "./chunk-IZW6MK3U.js";
+import "./chunk-EZG76F7R.js";
+import "./chunk-3DUAGYGP.js";
+import "./chunk-YYRDLFSJ.js";
+import "./chunk-EMCAWMHC.js";
+import "./chunk-WHOJWOSV.js";
+import "./chunk-LH6Z6KFV.js";
+import "./chunk-HJPTWBLH.js";
+import "./chunk-GNPVYOPB.js";
+import "./chunk-4HT3BNZ7.js";
+export {
+  compileBundle,
+  exportBundleJson,
+  loadDefault,
+  parseArgs,
+  printHelp,
+  readVersion,
+  resolveHelpRequest,
+  resolveLockPath,
+  run
+};
+//# sourceMappingURL=cli.js.map

package/dist/codegen-command-OOKK6AZK.js

@@ -0,0 +1,40 @@
+import {
+  blameGeneratedFile,
+  fetchWorkspaceBundle,
+  isMissingDependencyError,
+  runCodegenCommand,
+  verifyCrashEntry
+} from "./chunk-TRU5OHQ5.js";
+import "./chunk-26CNBZE2.js";
+import "./chunk-QTNO2WD6.js";
+import "./chunk-ZUTSMMAG.js";
+import "./chunk-WKP4D5MO.js";
+import "./chunk-VKFQJEMW.js";
+import "./chunk-47WDWMBJ.js";
+import "./chunk-X4DVXBFY.js";
+import "./chunk-3IGNIP6R.js";
+import "./chunk-C56BC2FY.js";
+import "./chunk-7REDODS2.js";
+import "./chunk-MZUI3JNX.js";
+import "./chunk-RVB7ITKN.js";
+import "./chunk-4BXJGVZ3.js";
+import "./chunk-FJ6ZS5KB.js";
+import "./chunk-YGPIY3WT.js";
+import "./chunk-IZW6MK3U.js";
+import "./chunk-EZG76F7R.js";
+import "./chunk-3DUAGYGP.js";
+import "./chunk-YYRDLFSJ.js";
+import "./chunk-EMCAWMHC.js";
+import "./chunk-WHOJWOSV.js";
+import "./chunk-LH6Z6KFV.js";
+import "./chunk-HJPTWBLH.js";
+import "./chunk-GNPVYOPB.js";
+import "./chunk-4HT3BNZ7.js";
+export {
+  blameGeneratedFile,
+  fetchWorkspaceBundle,
+  isMissingDependencyError,
+  runCodegenCommand,
+  verifyCrashEntry
+};
+//# sourceMappingURL=codegen-command-OOKK6AZK.js.map

package/dist/codegen.d.ts

@@ -0,0 +1,114 @@
+import { a1 as Statement, a8 as Tag, w as FilterXdo, a9 as TaggedValue, p as FieldDescriptor, Z as ResponseDef } from './response-CVAE2kMj.js';
+
+/** A stored statement envelope as it appears in a Xano bundle's `run[]`. */
+type RawEnvelope = Record<string, unknown>;
+/**
+ * Wrap a stored statement envelope so it compiles back to itself verbatim.
+ *
+ * Every key present on `envelope` — including keys this SDK does not model —
+ * survives untouched, and a key the envelope does not carry is NOT invented: an
+ * engine that omits a key at its default gets that exact shape back.
+ *
+ * @param envelope A stored `run[]` entry. Must be an object carrying a `name`.
+ */
+declare function raw(envelope: RawEnvelope): Statement;
+
+/**
+ * `rawValue()` — the value-level escape hatch codegen emits for a stored value it
+ * cannot express through `c.*` / `ref` / `inp` / `withFilters`.
+ *
+ * `Value` is structurally just `{value, tag, filters}`, so an annotated literal
+ * is already byte-exact; this wrapper exists for two reasons a bare literal does
+ * not cover. It types the `tag` as a real `Tag` so the literal also checks out in
+ * a widening position (a `const` declaration in a shared file, not only a
+ * contextually-typed argument), and it makes every non-idiomatic value in a
+ * generated tree greppable by one name.
+ *
+ * Reached via `@xanots/sdk/codegen`, alongside `raw()` — same reasoning
+ * (KTD-10): a passthrough should not sit in tab-completion next to `c.text`.
+ */
+
+/**
+ * A stored value as it appears in a bundle. `filters` defaults to none.
+ *
+ * `value` admits the NATIVE scalar spellings as well as the string one, because
+ * the engine stores both and this type describes what a bundle holds rather than
+ * what the SDK writes. The corpus is genuinely mixed — the same tag appears with
+ * a quoted and an unquoted value in one workspace — and codegen echoes whichever
+ * it found. Declaring it `string` alone made a pulled tree fail its own
+ * type-check (issue #133), which broke every npm script in the scaffold, since
+ * each one runs `tsc --noEmit` first.
+ *
+ * Coercing to the string form at emit would be the other repair. It is the wrong
+ * one for `null`: `normalize()` reconciles a numeric or boolean `value` with its
+ * string spelling, so those compare equal either way, but it does NOT do that for
+ * `null` — so emitting `"null"` for a stored `null` would change the bytes and
+ * fail the round trip.
+ */
+interface RawValueInput {
+    readonly value: string | number | boolean | null;
+    readonly tag: Tag;
+    readonly filters?: readonly FilterXdo[];
+}
+/**
+ * Carry a stored tagged value through verbatim.
+ *
+ * The cast is the point of the escape hatch: `TaggedValue.value` is declared
+ * `string` because that is what every `c.*` constructor writes, while a bundle
+ * may hold a native scalar under the same key. Preserving the stored spelling is
+ * what keeps the round trip exact, so the runtime value is passed through
+ * untouched rather than being coerced to satisfy the declaration.
+ */
+declare function rawValue(v: RawValueInput): TaggedValue;
+
+/** A stored field envelope as it appears in a bundle's `schema[]` / `input[]`. */
+type RawFieldEnvelope = Record<string, unknown>;
+/**
+ * Carry a stored field envelope through encoding unchanged.
+ *
+ * The envelope's own `name` and `type` win over the map key it is attached to,
+ * and a key the envelope does not carry is NOT invented. Preservation is the
+ * whole contract: nothing about the stored shape is rewritten to match its
+ * surroundings, and nothing is added to it.
+ *
+ * @param envelope A stored `schema[]` / `input[]` entry. Must carry `name` and `type`.
+ */
+declare function rawField(envelope: RawFieldEnvelope): FieldDescriptor;
+
+/**
+ * `rawResponse()` — the response-level verbatim passthrough.
+ *
+ * The fourth and last escape hatch, alongside `raw()` for statements,
+ * `rawValue()` for values, and `rawField()` for fields. Together they mean a
+ * pulled workspace never loses data on the way into TypeScript: whatever the
+ * engine stored comes back out unchanged, whether or not this SDK models it.
+ *
+ * It is needed because `encodeResponse` writes `_xsid` and `disabled`
+ * unconditionally at their defaults. No authoring surface reaches either, so a
+ * stored `result[]` item that sets one differently cannot round-trip through the
+ * `response:` field in any form. This carries the whole `result[]` array
+ * instead.
+ *
+ * Reached via `@xanots/sdk/codegen`, never from the discoverable authoring
+ * namespace, for the same reason `raw()` stays off `s` (KTD-10).
+ */
+
+/** A stored `result[]` entry as it appears in a bundle. */
+type RawResponseEnvelope = Record<string, unknown>;
+/**
+ * Carry a stored `result[]` array through encoding unchanged.
+ *
+ * A key an item does not carry is **NOT** invented. Preservation is the whole
+ * contract: only key ordering is normalized, and nothing is added.
+ *
+ * That absence rule is not incidental. `raw()` and `rawField()` both shipped
+ * completing absent keys with their defaults, which silently broke their own
+ * passthrough contract — the engine omits keys at their defaults, so filling
+ * them in changes the bytes on the way back. This preserves absence from the
+ * start rather than being fixed into it later.
+ *
+ * @param items Stored `result[]` entries. An empty array means "no response".
+ */
+declare function rawResponse(items: readonly RawResponseEnvelope[]): ResponseDef;
+
+export { type RawEnvelope, type RawFieldEnvelope, type RawResponseEnvelope, type RawValueInput, raw, rawField, rawResponse, rawValue };

package/dist/codegen.js

@@ -0,0 +1,71 @@
+import {
+  raw
+} from "./chunk-RVB7ITKN.js";
+import {
+  RAW_FIELD,
+  rawResponse
+} from "./chunk-LH6Z6KFV.js";
+
+// src/values/raw-value.ts
+function rawValue(v) {
+  return { value: v.value, tag: v.tag, filters: [...v.filters ?? []] };
+}
+
+// src/fields/raw-field.ts
+var CANONICAL_KEYS = [
+  "name",
+  "type",
+  "_xsid",
+  "description",
+  "nullable",
+  "default",
+  "merge",
+  "hidden",
+  "override",
+  "customize",
+  "required",
+  "values",
+  "mode",
+  "format",
+  "sensitive",
+  "list",
+  "vector",
+  "access",
+  "style",
+  "children",
+  "methods",
+  "market_item",
+  "is_settings_registry"
+];
+function rawField(envelope) {
+  if (envelope == null || typeof envelope !== "object" || Array.isArray(envelope)) {
+    throw new Error(
+      'rawField() expects a stored field envelope object \u2014 at minimum `{ name: "\u2026", type: "text" }` \u2014 but received ' + (envelope === null ? "null" : Array.isArray(envelope) ? "an array" : typeof envelope)
+    );
+  }
+  const { name, type } = envelope;
+  if (typeof name !== "string" || name === "") {
+    throw new Error('rawField() envelope is missing a `name`, e.g. `{ name: "email", type: "email" }`.');
+  }
+  if (typeof type !== "string" || type === "") {
+    throw new Error(`rawField() envelope for "${name}" is missing a \`type\`, e.g. "text" or "int".`);
+  }
+  const stored = {};
+  for (const key of CANONICAL_KEYS) {
+    if (Object.hasOwn(envelope, key)) stored[key] = envelope[key];
+  }
+  for (const key of Object.keys(envelope)) {
+    if (!Object.hasOwn(stored, key)) stored[key] = envelope[key];
+  }
+  return {
+    type,
+    options: { [RAW_FIELD]: stored }
+  };
+}
+export {
+  raw,
+  rawField,
+  rawResponse,
+  rawValue
+};
+//# sourceMappingURL=codegen.js.map