@xanots/xanoscript 0.0.1

package/dist/plugin.js

@@ -0,0 +1,483 @@
+import {
+  emitWorkspaceMultidoc,
+  layoutRoots,
+  parseDocument,
+  placeMultidoc
+} from "./chunk-677U72GF.js";
+
+// src/plugin.ts
+import { relative as relative3 } from "path";
+
+// src/diff.ts
+var SEPARATOR = "\n---\n";
+var IDENTITY_SEPARATOR = "\0";
+function docHeader(doc) {
+  for (const line of doc.split("\n")) {
+    const t = line.trim();
+    if (t !== "" && !t.startsWith("//")) return t;
+  }
+  return doc.trim().split("\n")[0] ?? "";
+}
+function docIdentity(doc) {
+  const parsed = parseDocument(doc);
+  if (parsed === null) return docHeader(doc);
+  return [parsed.type, parsed.name, parsed.verb ?? "", parsed.apiGroup ?? ""].join(IDENTITY_SEPARATOR);
+}
+function apiGroupIdentity(name) {
+  return ["api_group", name, "", ""].join(IDENTITY_SEPARATOR);
+}
+function splitDocs(text) {
+  const map = /* @__PURE__ */ new Map();
+  const body = text.replace(/\n$/, "");
+  if (body === "") return map;
+  for (const doc of body.split(SEPARATOR)) {
+    const id = docIdentity(doc);
+    const list = map.get(id) ?? [];
+    list.push(doc);
+    map.set(id, list);
+  }
+  return map;
+}
+function diffMultidocs(engine, local) {
+  const engineDocs = splitDocs(engine);
+  const localDocs = splitDocs(local);
+  const diffs = [];
+  let docs = 0;
+  let identical = 0;
+  for (const [id, list] of engineDocs) {
+    const other = localDocs.get(id) ?? [];
+    for (const [i, doc] of list.entries()) {
+      docs++;
+      const mine = other[i];
+      if (mine === void 0) {
+        diffs.push({ header: docHeader(doc), status: "missing-local", lines: [] });
+        continue;
+      }
+      if (mine === doc) {
+        identical++;
+        continue;
+      }
+      const a = doc.split("\n");
+      const b = mine.split("\n");
+      const lines = [];
+      for (let n = 0; n < Math.max(a.length, b.length); n++) {
+        if (a[n] !== b[n]) lines.push([n + 1, a[n], b[n]]);
+      }
+      const first = lines[0];
+      diffs.push({ header: docHeader(doc), status: "changed", line: first[0], engine: first[1], local: first[2], lines });
+    }
+  }
+  for (const [id, list] of localDocs) {
+    const have = engineDocs.get(id)?.length ?? 0;
+    for (let i = have; i < list.length; i++) {
+      docs++;
+      diffs.push({ header: docHeader(list[i]), status: "missing-engine", lines: [] });
+    }
+  }
+  return { docs, identical, diffs };
+}
+function diffsFor(diff, identities, engine) {
+  const byHeader = /* @__PURE__ */ new Map();
+  for (const doc of engine.replace(/\n$/, "").split(SEPARATOR)) byHeader.set(docHeader(doc), docIdentity(doc));
+  return new Set(diff.diffs.filter((d) => identities.has(byHeader.get(d.header) ?? "")));
+}
+
+// src/options.ts
+import { isAbsolute, relative as relative2, resolve, sep as sep2 } from "path";
+
+// src/writer.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
+import { dirname, join, relative, sep } from "path";
+function emitBundleXanoScript(bundle, options = {}) {
+  const parsed = typeof bundle === "string" ? JSON.parse(bundle) : bundle;
+  return emitWorkspaceMultidoc({ payload: parsed.payload ?? {} }, { features: { guid: options.guid ?? true } });
+}
+function treeReadme(p) {
+  const src = `\`${p.source}\``;
+  const from = p.sourceKind === "entry" ? `rendered from the TypeScript workspace ${src} by \`xanots export --xanoscript\`` : `rendered from ${p.source} by \`xanots ephemeral export --format xs-tree\``;
+  const edit = p.sourceKind === "entry" ? `Edit the TypeScript under \`${dirname(p.source) === "." ? "." : dirname(p.source)}/\` and regenerate with \`${p.regenerate}\`; anything changed here is overwritten by the next run.` : `Change the environment and regenerate with \`${p.regenerate}\`; anything changed here is overwritten by the next run.`;
+  const honest = p.check !== void 0 ? `\`${p.check}\` fails when the committed copy is stale, so a change cannot ship with a tree that disagrees with its source.` : "Regenerate it in the same change as the source, so the two never disagree.";
+  const lines = [
+    "# XanoScript rendering (generated)",
+    "",
+    `**Do not edit these files.** They are ${from}, and the whole directory is replaced on every run.`,
+    edit,
+    "",
+    "## Why it is committed",
+    "",
+    "A change to the backend shows up in review as the XanoScript it produces, one file per",
+    "object, beside the code that produced it. Read the diff here to see what the engine will",
+    "run; ask for changes in the source.",
+    "",
+    honest,
+    "",
+    "## After a merge, regenerate",
+    "",
+    "A clean merge is not evidence this tree is correct. Two branches that change different",
+    "objects merge without a conflict, yet one side's files were rendered before the other's",
+    "source change existed, so the merged tree can name an object that was renamed away.",
+    "Nothing in git can see that: at the text level the two sides never touched the same file.",
+    "",
+    `Regenerate after every merge${p.check !== void 0 ? `, and let \`${p.check}\` confirm it` : ""}.`,
+    "Never hand-edit a file here and never hand-resolve a conflict in one: the correct content",
+    "is whatever the source renders to, so the only valid resolution is to re-derive it.",
+    "",
+    "## Reading the tree",
+    "",
+    "| Path | What it is |",
+    "|---|---|",
+    `| \`workspace/<name>.xs\` | the workspace settings; \`workspace/trigger/\` its triggers |`,
+    `| \`table/<name>.xs\` | a table; \`table/trigger/\` its triggers |`,
+    `| \`api/<group>/<group>.xs\` | an API group; \`api/<group>/<path>/<name>_<VERB>.xs\` each of its endpoints |`,
+    `| \`function/\`, \`task/\`, \`addon/\`, \`middleware/\` | one file per object |`,
+    `| \`ai/agent/\`, \`ai/mcp_server/\`, \`ai/tool/\` | agents, MCP servers and tools; a \`trigger/\` folder beneath each |`,
+    `| \`realtime/server/<server>/channel/<channel>/message/\` | realtime servers, their channels, their messages, with triggers beneath each |`,
+    `| \`workflow_test/\`, \`microservice/\` | one file per object |`,
+    "",
+    `Names are snake_cased (\`get-user\` becomes \`get_user.xs\`); a path parameter such as \`{id}\` becomes a`,
+    `directory segment. This is the layout the Xano CLI writes on \`pull\`, so the tree can be`,
+    `pushed to an environment as it is (\`xano ephemeral push <env> --directory ${DEFAULT_TREE_DIR}\`) and`,
+    "pulls back byte for byte.",
+    "",
+    `A \`guid = "..."\` line is the object's identity, pinned by the workspace's \`xano.lock\`; it is what`,
+    `keeps a rename a rename on the engine. A \`placeholder "<name>"\` line marks a statement the`,
+    "engine's XanoScript cannot express; the export warns about each one.",
+    ""
+  ];
+  if (p.version !== void 0) lines.push(`Generated with @xanots/sdk ${p.version}.`, "");
+  return lines.join("\n");
+}
+var DEFAULT_TREE_DIR = "xanoscript";
+function projectTreeScripts(cwd) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
+    const scripts = Object.entries(pkg.scripts ?? {}).filter(([, cmd]) => /xanots export\b/.test(cmd) && /--xanoscript\b|--format[= ]xs-tree/.test(cmd));
+    const check = scripts.find(([, cmd]) => /--frozen-lock/.test(cmd))?.[0];
+    const regenerate = scripts.find(([name]) => name !== check)?.[0] ?? scripts[0]?.[0];
+    return {
+      regenerate: regenerate !== void 0 ? `npm run ${regenerate}` : "xanots export <entry> --xanoscript",
+      ...check !== void 0 ? { check: `npm run ${check}` } : {}
+    };
+  } catch {
+    return { regenerate: "xanots export <entry> --xanoscript" };
+  }
+}
+function planTree(dir, multidoc, provenance) {
+  if (existsSync(dir) && !statSync(dir).isDirectory()) {
+    throw new Error(`${dir} is a file; the XanoScript tree is a directory of .xs files. Name a directory, or use \`--format xs\` for one file.`);
+  }
+  const placed = placeMultidoc(multidoc);
+  const keep = new Set(placed.map((doc) => doc.relPath));
+  const stale = [];
+  for (const root of layoutRoots()) {
+    const abs = join(dir, root);
+    if (existsSync(abs)) collectStale(abs, dir, keep, stale);
+  }
+  const changed = placed.filter((doc) => !fileHolds(join(dir, ...doc.relPath.split("/")), doc.content)).map((doc) => doc.relPath);
+  const readme = treeReadme(provenance);
+  return { placed, changed, stale, readme, readmeChanged: !fileHolds(join(dir, "README.md"), readme) };
+}
+function fileHolds(abs, content) {
+  return existsSync(abs) && readFileSync(abs, "utf8") === content;
+}
+function checkXanoScriptTree(dir, multidoc, provenance) {
+  const plan = planTree(dir, multidoc, provenance);
+  return { changed: [...plan.changed, ...plan.readmeChanged ? ["README.md"] : []], removed: plan.stale };
+}
+function writeXanoScriptTree(dir, multidoc, provenance) {
+  const plan = planTree(dir, multidoc, provenance);
+  for (const rel of plan.stale) rmSync(join(dir, ...rel.split("/")));
+  for (const root of layoutRoots()) {
+    const abs = join(dir, root);
+    if (existsSync(abs)) removeEmptyDirs(abs);
+  }
+  mkdirSync(dir, { recursive: true });
+  const changed = new Set(plan.changed);
+  for (const doc of plan.placed) {
+    if (!changed.has(doc.relPath)) continue;
+    const abs = join(dir, ...doc.relPath.split("/"));
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, doc.content, "utf8");
+  }
+  if (plan.readmeChanged) writeFileSync(join(dir, "README.md"), plan.readme, "utf8");
+  return { written: plan.placed.map((doc) => doc.relPath), removed: plan.stale };
+}
+function collectStale(abs, root, keep, out) {
+  for (const entry of readdirSync(abs, { withFileTypes: true })) {
+    const child = join(abs, entry.name);
+    if (entry.isDirectory()) {
+      collectStale(child, root, keep, out);
+    } else if (entry.name.endsWith(".xs")) {
+      const rel = relative(root, child).split(sep).join("/");
+      if (!keep.has(rel)) out.push(rel);
+    }
+  }
+}
+function removeEmptyDirs(abs) {
+  for (const entry of readdirSync(abs, { withFileTypes: true })) {
+    if (entry.isDirectory()) removeEmptyDirs(join(abs, entry.name));
+  }
+  if (readdirSync(abs).length === 0) rmSync(abs, { recursive: true });
+}
+var AUTHORED_AS = {
+  // Emitted by `s.db.get_by_id` before 0.0.19; since then that builder emits the
+  // field match (`db.get` on `id`), so a bundle carrying this was built by an
+  // older SDK, or pulled from a workspace edited elsewhere.
+  "mvp:dbo_get": "s.db.get_by_id before @xanots/sdk 0.0.19 \u2014 re-export with the current SDK",
+  // Emitted by `s.security.create_guid`, removed in 0.0.20; `s.security.create_uuid` renders.
+  "mvp:guid": "s.security.create_guid, removed in @xanots/sdk 0.0.20 \u2014 use s.security.create_uuid"
+};
+function placeholderStatements(xanoscript) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const m of xanoscript.matchAll(/^\s*placeholder "([^"]*)"\s*$/gm)) counts.set(m[1], (counts.get(m[1]) ?? 0) + 1);
+  return [...counts].map(([name, count]) => ({ name, count, ...AUTHORED_AS[name] ? { authoredAs: AUTHORED_AS[name] } : {} }));
+}
+function placeholderWarning(xanoscript) {
+  const found = placeholderStatements(xanoscript);
+  if (found.length === 0) return null;
+  const list = found.map((f) => `${f.name} \xD7${f.count}${f.authoredAs ? ` (${f.authoredAs})` : ""}`).join(", ");
+  return `${found.reduce((n, f) => n + f.count, 0)} statement(s) have no XanoScript form and rendered as \`placeholder\`: ${list}. The engine's own pull renders them the same way, and pushing the placeholder does not recreate the statement.`;
+}
+
+// src/options.ts
+var PACKAGE_NAME = "@xanots/xanoscript";
+var FORBIDDEN_ROOTS = {
+  // A build directory is wiped by the build, so a committed review surface
+  // written into it is deleted by the next `npm run build` and silently
+  // regenerated — a tree that exists only between two commands.
+  dist: "a build directory the toolchain deletes and regenerates",
+  // The SDK's own scratch directory. A generated tree there is neither
+  // committed nor reviewable, which is the entire point of writing one.
+  ".xano": "the SDK's own scratch directory, which is not committed"
+};
+var OptionsError = class extends Error {
+  name = "OptionsError";
+};
+function fail(message) {
+  throw new OptionsError(`${PACKAGE_NAME}: ${message}`);
+}
+function resolveOptions(config, cwd) {
+  const raw = config ?? {};
+  const enabledRaw = raw.enabled;
+  if (enabledRaw !== void 0 && typeof enabledRaw !== "boolean") {
+    fail(`the "enabled" option must be true or false (got ${describe(enabledRaw)}).`);
+  }
+  const enabled = enabledRaw ?? true;
+  const dirRaw = raw.dir;
+  if (dirRaw !== void 0 && typeof dirRaw !== "string") {
+    fail(`the "dir" option must be a string naming a directory (got ${describe(dirRaw)}).`);
+  }
+  const dir = dirRaw === void 0 || dirRaw === "" ? DEFAULT_TREE_DIR : dirRaw;
+  if (isAbsolute(dir)) {
+    fail(`the "dir" option must be relative to the project, not an absolute path (got ${JSON.stringify(dir)}).`);
+  }
+  const absDir = resolve(cwd, dir);
+  const rel = relative2(cwd, absDir);
+  if (rel === "") {
+    fail(`the "dir" option must name a directory inside the project, not the project root itself (got ${JSON.stringify(dir)}).`);
+  }
+  if (rel === ".." || rel.startsWith(`..${sep2}`) || isAbsolute(rel)) {
+    fail(
+      `the "dir" option resolves outside the project root (${JSON.stringify(dir)} \u2192 ${absDir}). The tree directory is pruned on every write, so it must stay inside the project.`
+    );
+  }
+  const first = rel.split(sep2)[0] ?? "";
+  const why = FORBIDDEN_ROOTS[first];
+  if (why !== void 0) {
+    fail(`the "dir" option must not be inside ${JSON.stringify(first)} \u2014 ${why} (got ${JSON.stringify(dir)}).`);
+  }
+  return { enabled, dir, absDir };
+}
+function describe(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "an array";
+  return typeof v;
+}
+
+// src/plugin.ts
+var MIN_SDK = "0.0.29";
+var MAX_SDK_EXCLUSIVE = "0.1.0";
+var PEER_RANGE = `>=${MIN_SDK} <${MAX_SDK_EXCLUSIVE}`;
+function parseVersion(v) {
+  const m = /^(\d+)\.(\d+)\.(\d+)/.exec(v.trim());
+  return m === null ? null : [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+function compare(a, b) {
+  return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+}
+function assertSdkVersion(sdkVersion) {
+  if (sdkVersion.includes("-")) return;
+  const found = parseVersion(sdkVersion);
+  if (found === null) return;
+  const min = parseVersion(MIN_SDK);
+  const max = parseVersion(MAX_SDK_EXCLUSIVE);
+  if (compare(found, min) < 0 || compare(found, max) >= 0) {
+    throw new OptionsError(
+      `${PACKAGE_NAME} requires @xanots/sdk ${PEER_RANGE}, but ${sdkVersion} is running. Upgrade @xanots/sdk, or remove ${PACKAGE_NAME} from this project \u2014 the XanoScript tree is not written by an SDK outside that range.`
+    );
+  }
+}
+var Q_ENABLED = "xanoscript";
+var Q_DIR = "dir";
+var questions = [
+  {
+    id: Q_ENABLED,
+    label: "Commit a XanoScript rendering of the backend, so changes review as what the engine runs",
+    type: "boolean",
+    default: true
+  },
+  {
+    id: Q_DIR,
+    label: "Directory for the XanoScript tree",
+    type: "string",
+    default: DEFAULT_TREE_DIR,
+    // Derived from `id` this would be `--dir`, which reads as the SDK's own
+    // and would collide with the next module that wants a directory. The flag
+    // is namespaced to the thing it configures.
+    flag: "xanoscript-dir",
+    // A project that declined the tree is never asked where to put it, and —
+    // per the contract — the unasked question's default is NOT written to the
+    // config block either. Recording `dir` for a disabled module would put a
+    // directory nobody chose in front of the next reader.
+    when: (answers) => answers[Q_ENABLED] !== false
+  }
+];
+function files(answers) {
+  if (answers[Q_ENABLED] === false) return {};
+  const dir = typeof answers[Q_DIR] === "string" && answers[Q_DIR] !== "" ? answers[Q_DIR] : DEFAULT_TREE_DIR;
+  return {
+    gitattributes: [
+      "",
+      `# GitHub's built-in ".xs" language is Perl XS (tm_scope: source.c), so without`,
+      "# this every XanoScript file renders with C syntax highlighting and counts as",
+      "# Perl XS in the repository language bar. HCL is the closest built-in match to",
+      "# XanoScript's `block name { key = value }` grammar with // comments.",
+      "*.xs linguist-language=HCL",
+      "",
+      `# ${dir}/ is generated but committed on purpose: a backend change is`,
+      "# reviewed as the XanoScript it produces. Deliberately NOT linguist-generated:",
+      "# that is the one attribute that COLLAPSES a file in pull request diffs, which",
+      "# would hide the thing this directory exists to show. linguist-vendored drops it",
+      "# from the language bar and leaves the diff expanded.",
+      `${dir}/** linguist-vendored=true`
+    ],
+    config: { enabled: true, dir }
+  };
+}
+var NO_ENTRY_MESSAGE = "xanoscript \u2014 skipped: this bundle was supplied with `--bundle`, so there is no entry it was compiled from. The committed tree describes the source beside it; regenerate it by exporting the workspace entry.";
+async function onBundle(ctx) {
+  const opts = resolveOptions(ctx.config, ctx.cwd);
+  assertSdkVersion(ctx.sdkVersion);
+  if (!opts.enabled) return {};
+  if (ctx.entry === void 0) return { message: NO_ENTRY_MESSAGE };
+  const multidoc = emitBundleXanoScript(ctx.bundle, { guid: true });
+  const warnings = [];
+  const placeholders = placeholderWarning(multidoc);
+  if (placeholders !== null) warnings.push(placeholders);
+  const provenance = treeProvenance(ctx);
+  if (ctx.frozen) {
+    const { changed, removed: removed2 } = checkXanoScriptTree(opts.absDir, multidoc, provenance);
+    if (changed.length === 0 && removed2.length === 0) {
+      return { message: `xanoscript \u2713 ${opts.dir}/ matches the source`, ...warnings.length > 0 ? { warnings } : {} };
+    }
+    return {
+      failed: true,
+      message: `xanoscript \u2717 ${opts.dir}/ is stale \u2014 ${changed.length} file(s) differ, ${removed2.length} left over. Regenerate it and commit the result.`,
+      warnings: [
+        ...changed.slice(0, 20).map((f) => `differs: ${f}`),
+        ...removed2.slice(0, 20).map((f) => `no longer produced: ${f}`),
+        ...changed.length + removed2.length > 40 ? [`\u2026 ${changed.length + removed2.length - 40} more`] : [],
+        ...warnings
+      ]
+    };
+  }
+  const { written, removed } = writeXanoScriptTree(opts.absDir, multidoc, provenance);
+  return {
+    message: `xanoscript \u2192 ${opts.dir}/ (${written.length} document(s)${removed.length > 0 ? `, ${removed.length} removed` : ""})`,
+    ...warnings.length > 0 ? { warnings } : {}
+  };
+}
+function treeProvenance(ctx) {
+  const entry = ctx.entry;
+  const rel = relative3(ctx.cwd, entry);
+  return {
+    // A path outside the project (an absolute entry elsewhere) stays absolute
+    // rather than becoming a `../../` the README's reader cannot follow.
+    source: rel === "" || rel.startsWith("..") ? entry : rel,
+    sourceKind: "entry",
+    ...projectTreeScripts(ctx.cwd),
+    version: ctx.sdkVersion
+  };
+}
+async function onPreflight(ctx) {
+  const opts = resolveOptions(ctx.config, ctx.cwd);
+  assertSdkVersion(ctx.sdkVersion);
+  if (!opts.enabled) return {};
+  if (ctx.engineRendering.kind === "error") {
+    return {
+      message: "xanoscript ? the engine's rendering could not be fetched, so the emitter was not compared",
+      warnings: [ctx.engineRendering.why]
+    };
+  }
+  const engine = ctx.engineRendering.text;
+  const features = { guid: true };
+  const fromExported = emitWorkspaceMultidoc({ payload: ctx.exportedPayload }, { features });
+  const fromBundle = emitWorkspaceMultidoc({ payload: ctx.remappedPayload }, { features });
+  const port = diffMultidocs(engine, fromExported);
+  const exportedGroups = new Set(records(ctx.exportedPayload.app).map((a) => String(a.name ?? "")));
+  const queryLessApiGroups = records(ctx.remappedPayload.app).map((a) => String(a.name ?? "")).filter((name) => name !== "" && !exportedGroups.has(name));
+  const skipped = new Set(
+    [...diffsFor(port, new Set(queryLessApiGroups.map(apiGroupIdentity)), engine)].filter((d) => d.status === "missing-local")
+  );
+  port.diffs = port.diffs.filter((d) => !skipped.has(d));
+  const compared = port.docs - skipped.size;
+  const warnings = [];
+  if (skipped.size > 0) {
+    warnings.push(`${skipped.size} api group(s) without queries are absent from the engine's JSON export and were not compared`);
+  }
+  const failed = port.diffs.length > 0;
+  const message = failed ? `xanoscript \u2717 emitter differs from the engine in ${port.diffs.length} of ${compared} document(s)` : `xanoscript \u2713 emitter matches the engine (${compared} document(s), byte-identical)`;
+  if (failed) {
+    const shown = ctx.verbose ? port.diffs : port.diffs.slice(0, 10);
+    for (const d of shown) warnings.push(describeDiff(d, ctx.verbose));
+    if (!ctx.verbose && port.diffs.length > shown.length) warnings.push(`\u2026 ${port.diffs.length - shown.length} more (run with --verbose)`);
+  }
+  const authored = diffMultidocs(engine, fromBundle);
+  const authoredDiffs = authored.diffs.filter((d) => d.status !== "changed" || d.lines.some(([, e, l]) => !isGuidLine(e) || !isGuidLine(l)));
+  if (authoredDiffs.length > 0) {
+    warnings.push(
+      `this bundle's own rendering differs from the engine in ${authoredDiffs.length} document(s) \u2014 the JSON the engine fills in on import, not the emitter`
+    );
+    if (ctx.verbose) for (const d of authoredDiffs) warnings.push(`  ${describeDiff(d, false)}`);
+  }
+  return { message, ...failed ? { failed: true } : {}, ...warnings.length > 0 ? { warnings } : {} };
+}
+function describeDiff(d, verbose) {
+  if (d.status !== "changed") return `${d.header}  ${d.status === "missing-local" ? "not rendered locally" : "not rendered by the engine"}`;
+  const head = `${d.header}  line ${d.line}: engine ${fmt(d.engine)}, local ${fmt(d.local)}`;
+  if (!verbose) return head;
+  return [head, ...d.lines.slice(1).map(([n, e, l]) => `    line ${n}: engine ${fmt(e)}, local ${fmt(l)}`)].join("\n");
+}
+function isGuidLine(line) {
+  return line !== void 0 && /^\s*guid = "/.test(line);
+}
+function fmt(v) {
+  return v === void 0 ? "(absent)" : JSON.stringify(v);
+}
+function records(v) {
+  return Array.isArray(v) ? v.filter((r) => typeof r === "object" && r !== null) : [];
+}
+var plugin = {
+  kind: "toolchain",
+  questions,
+  files,
+  onBundle,
+  onPreflight
+};
+var plugin_default = plugin;
+export {
+  PEER_RANGE,
+  assertSdkVersion,
+  plugin_default as default
+};
+//# sourceMappingURL=plugin.js.map

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@xanots/xanoscript",
+  "version": "0.0.1",
+  "description": "Renders a XanoTS workspace to XanoScript — the language the Xano engine runs. A file-for-file port of the engine's encoder, proven byte-for-byte against the engine's own golden corpus.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Xano",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "xano",
+    "xanots",
+    "xanoscript",
+    "toolchain",
+    "codegen"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xanots/xanoscript.git"
+  },
+  "homepage": "https://github.com/xanots/xanoscript#readme",
+  "bugs": {
+    "url": "https://github.com/xanots/xanoscript/issues"
+  },
+  "sideEffects": false,
+  "xanots": {
+    "kind": "toolchain",
+    "plugin": "./dist/plugin.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "import": "./dist/plugin.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "README.md",
+    "llms.txt"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint .",
+    "xs:vendor": "tsx scripts/xs-engine/vendor-engine.ts",
+    "xs:corpus": "tsx scripts/xs-engine/sync-corpus.ts",
+    "xs:drift": "tsx scripts/xs-engine/drift.ts",
+    "xs:report": "tsx scripts/xs-engine/corpus-report.ts",
+    "audit:credentials": "bash scripts/scan-corpus-secrets.sh",
+    "prepublishOnly": "npm run build",
+    "release": "npm publish --access public",
+    "release:beta": "npm version prerelease --preid=beta -m \"chore(release): %s\" && npm publish --tag beta --access public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "peerDependencies": {
+    "@xanots/sdk": ">=0.0.29 <0.1.0"
+  },
+  "dependencies": {
+    "lodash.snakecase": "4.1.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "@types/lodash.snakecase": "^4.1.9",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "@xanots/sdk": "^0.0.29",
+    "eslint": "^9.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.23.1",
+    "typescript": "^5.5.0",
+    "vitest": "^3.2.6",
+    "yaml": "^2.9.1"
+  }
+}