@xanots/sdk 0.0.11 → 0.0.12

package/dist/chunk-ANUDXFEX.js

@@ -1,881 +0,0 @@
-import {
-  colorTokens,
-  defaultThemeChoice,
-  fontDependencies,
-  fontImports,
-  fontThemeVars,
-  orderedTokens
-} from "./chunk-Q77KNEUL.js";
-
-// src/emit/init-templates.ts
-function sdkDep(sdkVersion) {
-  const parsed = /^(\d+)\.(\d+)\.\d+/.exec(sdkVersion);
-  if (!parsed) return ">=0.0.1 <0.1.0";
-  const [major, minor] = [Number(parsed[1]), Number(parsed[2])];
-  const ceiling = major > 0 ? `${major + 1}.0.0` : `0.${minor + 1}.0`;
-  return `>=${sdkVersion} <${ceiling}`;
-}
-function renderPackageJson({ appName, sdkVersion }, preset, choice = defaultThemeChoice()) {
-  const check = preset.checkCmd;
-  const pkg = {
-    name: appName,
-    version: "0.1.0",
-    private: true,
-    type: "module",
-    scripts: {
-      dev: "vite",
-      build: `${check} && vite build`,
-      preview: "vite preview",
-      typecheck: check,
-      // Both are prefixed with a typecheck: the export pass validates what it
-      // can see in the encoded bundle, and TypeScript validates the rest. Only
-      // `build` used to run `tsc`, so anyone following the documented workflow
-      // shipped with the compiler's half of the checks never run.
-      // `--lock` on both: object identity derives from `(type, name)`, so
-      // without a lock a rename re-derives the guid and the engine does
-      // delete-and-recreate instead of rename-in-place. The lock has to be
-      // adopted BEFORE the identities matter — by the time a rename lands
-      // against data anyone cares about, the guids have already drifted and
-      // recovery is `xanots lock import`. The scaffold is the earliest possible
-      // moment, so it opts in from the first export (issue #26). Once the file
-      // exists every export uses it, flag or not.
-      "xano:export": `${check} && xanots export ./xano/index.ts --out workspace.json --lock`,
-      // Runs `build` rather than `check` directly: `--static ./frontend/dist`
-      // needs that directory to EXIST, and only `vite build` writes it. Pointing
-      // the flag at a directory the script never produced meant a fresh clone
-      // running the one documented command had no `dist` to ship (issue #241).
-      // `build` already prefixes the same typecheck, so this is one check, not
-      // two.
-      "xano:deploy": `npm run build && xanots deploy ./xano/index.ts --static ./frontend/dist --lock`,
-      // The CI guard: fails instead of changing xano.lock, so an uncommitted
-      // identity change is caught in review rather than on a deploy.
-      "xano:check": `${check} && xanots export ./xano/index.ts --out workspace.json --frozen-lock`,
-      // No compile step and no entry file: this runs what is DEPLOYED, so it
-      // pairs with `xano:deploy` rather than repeating its work. Exits 5 on a
-      // failing suite, which is what makes it usable as a CI gate.
-      "xano:test": "xanots test run-all",
-      // Framework-owned scripts, last so a preset can add to the set but the
-      // shared xano:* contract above stays the same in every scaffold.
-      ...preset.extraScripts
-    },
-    dependencies: {
-      // `@xanots/sdk` is the only XanoTS dependency a scaffold ships with.
-      // Add-ons (`@xanots/auth`, and the packages that follow it) are installed
-      // on demand — a project that never registers auth should not carry it,
-      // and an add-on's release cadence is its own, not the CLI's.
-      "@xanots/sdk": sdkDep(sdkVersion),
-      ...preset.dependencies,
-      // The icon set and the typefaces are choices, not framework constants, so
-      // they are merged here rather than sitting in `preset.dependencies`. Both
-      // land after the preset's own entries: a preset that still names an icon
-      // package would otherwise win over the set the user actually picked.
-      ...preset.iconBinding(choice.icons).dependency,
-      ...fontDependencies(choice.fonts)
-    },
-    devDependencies: { ...preset.devDependencies },
-    // Not ">=20": Vite 8 and vite-plugin-svelte 7 both declare
-    // `^20.19 || >=22.12`, so 20.0–20.18 installs the toolchain and then fails
-    // to run it. Stating the real floor turns that into an install-time
-    // warning instead of a confusing crash.
-    engines: { node: ">=20.19" }
-  };
-  return JSON.stringify(pkg, null, 2) + "\n";
-}
-function renderTsconfig(preset) {
-  const aliasPaths = Object.keys(preset.tsconfigPaths).length > 0 ? { paths: { ...preset.tsconfigPaths } } : {};
-  const tsconfig = {
-    // Present only when the framework generates a config to build on — see
-    // FrontendPreset.tsconfigExtends. The `include` below is re-declared on
-    // top of it deliberately: an extended config's `include` is REPLACED, not
-    // merged, and dropping `xano` here would leave the backend unchecked while
-    // every command still exits 0.
-    ...preset.tsconfigExtends === void 0 ? {} : { extends: preset.tsconfigExtends },
-    compilerOptions: {
-      target: "ES2022",
-      lib: ["ES2022", "DOM", "DOM.Iterable"],
-      module: "ESNext",
-      moduleResolution: "bundler",
-      ...preset.tsconfigOptions,
-      strict: true,
-      noEmit: true,
-      esModuleInterop: true,
-      skipLibCheck: true,
-      resolveJsonModule: true,
-      isolatedModules: true,
-      types: ["node", "vite/client"],
-      ...aliasPaths
-    },
-    // Both halves of the project typecheck together: the XanoTS backend and
-    // the frontend that derives its types from the backend's defs. A preset
-    // that extends a generated config appends whatever that config listed —
-    // `include` is replaced, not merged, so anything it declared is otherwise
-    // silently dropped. See FrontendPreset.tsconfigInclude.
-    include: ["xano", "frontend/src", ...preset.tsconfigInclude ?? []]
-  };
-  return JSON.stringify(tsconfig, null, 2) + "\n";
-}
-function renderViteConfig(preset) {
-  const root = preset.viteRoot === void 0 ? "frontend" : preset.viteRoot;
-  const build = preset.viteBuild === void 0 ? { outDir: "dist", emptyOutDir: true } : preset.viteBuild;
-  const header = root === null ? `// Vite's root is the project root. The framework resolves its own file
-// locations from the plugin config below \u2014 this file is the ONLY place that
-// config lives \u2014 and routes the build through its adapter, which writes
-// frontend/dist, the directory \`npm run xano:deploy\` ships as the frontend.` : `// Vite's root is the ${root}/ folder, so index.html and the app live there
-// while the XanoTS backend sits in xano/ as a peer. The build lands in
-// ${root}/dist, which \`npm run xano:deploy\` ships as the static frontend.`;
-  const rootBlock = root === null ? "" : `  root: ${JSON.stringify(root)},
-  // Vite resolves \`.env\` files against \`root\`, which is ${root}/ here \u2014 but
-  // \`.env.example\` sits at the project root, so that is where anyone will
-  // actually put their \`.env.local\`. Point envDir back at this file's own
-  // directory so VITE_XANO_HOST is picked up in dev.
-  envDir: fileURLToPath(new URL(".", import.meta.url)),
-`;
-  const buildBlock = build === null ? "" : `  build: ${renderInlineObject(build)},
-`;
-  const aliasBlock = preset.aliasName === null ? "" : `  resolve: {
-    alias: {
-      // The alias the UI kit writes its imports against. Resolved from this
-      // file rather than from Vite's root so it points at the right directory
-      // either way. Keep in sync with the \`paths\` entry in tsconfig.json.
-      "${preset.aliasName}": fileURLToPath(new URL("./${preset.aliasTarget}", import.meta.url)),
-    },
-  },
-`;
-  const fileUrlImport = rootBlock === "" && aliasBlock === "" ? "" : `import { fileURLToPath } from "node:url";
-`;
-  return `${fileUrlImport}import { defineConfig } from "vite";
-${preset.viteImports.join("\n")}
-
-${header}
-export default defineConfig({
-${rootBlock}${buildBlock}  plugins: [${preset.vitePlugins.join(", ")}],
-${aliasBlock}  server: { host: "127.0.0.1", port: 5173 },
-});
-`;
-}
-function renderInlineObject(obj) {
-  const entries = Object.entries(obj).map(([k, v]) => `${k}: ${JSON.stringify(v)}`);
-  return entries.length === 0 ? "{}" : `{ ${entries.join(", ")} }`;
-}
-function renderIndexHtml({ appName }, preset, choice = defaultThemeChoice()) {
-  if (preset.entryScript === void 0) {
-    throw new Error(`The ${preset.id} preset owns its own HTML entry; renderIndexHtml does not apply.`);
-  }
-  return `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>${appName}</title>
-${renderThemeScript(choice.dark)}  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="${preset.entryScript}"></script>
-  </body>
-</html>
-`;
-}
-function renderGitignore(preset) {
-  const framework = (preset?.gitignoreEntries ?? []).map((e) => `${e}
-`).join("");
-  return `node_modules/
-dist/
-workspace.json
-.xano/
-.env
-.env.local
-*.local
-${framework}
-# Not ignored, on purpose: xano/xano.lock pins object identity across renames
-# and environments. Commit it.
-`;
-}
-function renderEnvExample() {
-  return `# Point the frontend at a deployed Xano backend. Leave unset to run the UI
-# with no backend. When you \`npm run xano:deploy\`, the backend URL is injected
-# as window.XANO_HOST at runtime instead \u2014 no rebuild needed.
-VITE_XANO_HOST=https://your-instance.xano.io
-`;
-}
-function renderReadme({ appName }, preset, choice = defaultThemeChoice()) {
-  return `# ${appName}
-
-A [XanoTS](https://www.npmjs.com/package/@xanots/sdk) project: a Xano
-backend authored in TypeScript under [\`xano/\`](xano/), and a ${preset.label}
-frontend under [\`frontend/\`](frontend/) that derives its request paths and
-types from the backend defs \u2014 so the two can't drift.
-
-## Quick start
-
-\`\`\`bash
-npm install
-npm run dev          # run the frontend (no backend needed yet)
-\`\`\`
-
-Then author your backend in [\`xano/index.ts\`](xano/index.ts) \u2014 start with the
-walkthrough in [\`xano/EXAMPLE.md\`](xano/EXAMPLE.md).
-
-## Deploy
-
-\`\`\`bash
-xanots login            # once, to authenticate against your Xano account
-npm run xano:deploy     # build the frontend, then ship it with the backend
-\`\`\`
-
-- \`npm run xano:export\` compiles the backend to \`workspace.json\` (don't commit it).
-- \`npm run xano:deploy\` deploys the backend and the built frontend to a live
-  **ephemeral** environment and prints its URL. Run it again to refresh the same
-  environment; if it expired, a fresh one is created and the new URL is called out.
-- \`xanots status\` says who you are signed in as, which workspace you are bound to, and
-  which environment this project last deployed to \u2014 its URL, and when it expires. You
-  never have to remember the environment's name.
-- \`npm run xano:test\` runs the tests the DEPLOYED environment carries \u2014 the \`tests\`
-  on a query/function/middleware and any \`workflowTest()\`. It compiles nothing, so
-  deploy first. A failing suite exits 5, distinct from a crash. \`xanots deploy
-  ./xano/index.ts --test\` does both in one step.
-
-## \`xano.lock\` \u2014 commit it
-
-Object identity derives from \`(type, name)\`, so a rename would otherwise change
-an object's guid and the engine would **delete and recreate** it rather than
-renaming it in place \u2014 losing its rows on a record-preserving import.
-[\`xano/xano.lock\`](xano/xano.lock) freezes each guid and each API group's
-canonical slug, so renames and re-deploys keep the same identities (and the same
-public URLs).
-
-It is created by \`npm run xano:export\` or \`npm run xano:deploy\`, and **must be
-committed**. Adopt it from the first export: once identities have drifted, the
-recovery path is \`xanots lock import <live-bundle.json> --lock=xano/xano.lock\`
-against the deployed workspace.
-
-\`\`\`bash
-npm run xano:check      # CI: fail if the export would change xano.lock
-\`\`\`
-
-To rename an object: rename it in code, run \`npm run xano:export\` (stderr prints
-the exact fix-up), run \`xanots lock rename <kind> <old> <new> --lock=xano/xano.lock\`,
-then export again. \`lock rename\` and \`lock import\` need that flag here \u2014 they take no
-entry file, so they look for the lock in the current directory, while
-\`lock prune ./xano/index.ts\` derives it from the entry like \`export\` does.
-
-## The one contract
-
-[\`frontend/src/lib/api.ts\`](frontend/src/lib/api.ts) imports the XanoTS query
-defs and derives paths (\`getPath()\`) and request/response types
-(\`InferInput\` / \`InferResponse\`) from them. Never hand-type a URL or a request
-body \u2014 change a def and the frontend types follow.
-
-> To spot-check a def from Node (read \`getPath()\`/\`verb\`, log a value), run a real
-> file with \`tsx <file.ts>\` **from inside the project root** \u2014 not \`tsx -e\`, not
-> bare \`node file.ts\`, and not from another directory (they mis-resolve the
-> intra-workspace \`.js\` imports and the \`@xanots/sdk\` specifier). Or use
-> \`xanots routes xano/index.ts\` to list every endpoint's verb + path.
-
-## The frontend
-
-${preset.readmeFrontendSection(choice.icons)}
-
-${renderReadmeThemingSection(choice)}
-
-## Add-ons
-
-XanoTS is composable with other \`@xanots/*\` packages:
-
-- **[\`@xanots/auth\`](https://www.npmjs.com/package/@xanots/auth)** \u2014 turnkey
-  authentication (user/login/signup tables and endpoints). Install it with
-  \`xanots marketplace install @xanots/auth\`, then register it in
-  \`xano/index.ts\`. Authentication only \u2014 **not** authorization: it has no
-  roles, permissions, or route guards. Build those with \`@xanots/sdk\` (a role
-  column plus a \`s.precondition\` per endpoint).
-- More \`@xanots/*\` packages register onto the same workspace. This list
-  does not update itself \u2014 run \`xanots marketplace list\` for the live
-  catalogue, \`xanots marketplace search <words>\` to narrow it, and
-  \`xanots marketplace details <package>\` to see what an add-on installs and
-  how to register it. All three work before you log in.
-
-None of these ship with the scaffold. Install one only when you need it \u2014 an
-add-on you never register is weight in \`package.json\` for nothing.
-`;
-}
-function renderXanoIndex({ appName }) {
-  return `import { workspace } from "@xanots/sdk";
-
-/**
- * The ${appName} backend.
- *
- * A workspace is assembled by registering typed objects onto a workspace()
- * instance and default-exporting it. This starter is intentionally empty and
- * already compiles + deploys \u2014 add your first table and endpoint below.
- *
- * \u2500\u2500 Add your first table + endpoint \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
- *
- *   import { workspace, table, apiGroup, query, f, input, s, ref, c, expect, resp } from "@xanots/sdk";
- *
- *   const notes = table({
- *     name: "notes",
- *     // \`id\` (int PK) + \`created_at\` (epochms) are auto-injected.
- *     schema: {
- *       body: f.text({ required: true }),
- *     },
- *   });
- *
- *   const api = apiGroup({ name: "notes", canonical: "notes" }); // pin the slug
- *
- *   const createNote = query({
- *     name: "create_note",
- *     verb: "POST",
- *     apiGroup: api,
- *     input: { body: input.text({ required: true }) },
- *     // ...build the stack with the s.* statement helpers...
- *     // Assertions ride along with the object they cover; \`npm run xano:test\`
- *     // runs them against whatever you last deployed.
- *     tests: [
- *       {
- *         name: "creates a note",
- *         input: { body: c.text("hello") },
- *         expect: [expect.to_be_defined(resp())],
- *       },
- *     ],
- *   });
- *
- *   export default workspace("${appName}")
- *     .registerTables([notes])
- *     .registerApiGroups([api])
- *     .registerQueries([createNote]);
- *
- * Discover the exact builders and options from the package's own types and its
- * shipped docs \u2014 read \`node_modules/@xanots/sdk/llms.txt\` first (it ends with a
- * map of the \`llms/*.md\` topic files), then the .d.ts files.
- * See \`xano/EXAMPLE.md\` for the full walkthrough.
- *
- * \u2500\u2500 Optional add-ons \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
- * Nothing below is installed. Reach for an add-on when you need it, not before.
- *
- * @xanots/auth registers turnkey auth (user/login/signup) onto this same
- * workspace. Install it first (\`xanots marketplace install @xanots/auth\`), then
- * \`registerAuth(workspace("${appName}"), { canonical: "authn" })\` returns the
- * instance to chain your own .register*() calls onto:
- *
- *   registerAuth(workspace("${appName}"), { canonical: "authn" })
- *     .registerTables([notes])
- *     .registerApiGroups([api])
- *     .registerQueries([createNote]);
- *
- * That is not the whole catalogue. \`xanots marketplace list\` prints every
- * published add-on and \`xanots marketplace details <package>\` prints what one
- * installs plus the registration to paste here \u2014 no login required.
- */
-export default workspace("${appName}");
-`;
-}
-function renderXanoExampleMd({ appName }) {
-  return `# Building your ${appName} backend
-
-The backend lives in [\`index.ts\`](index.ts) and is a single default-exported
-\`workspace()\`. You grow it by registering typed objects.
-
-## Learn the library from the library
-
-Everything you need is in the package itself:
-
-- \`node_modules/@xanots/sdk/llms.txt\` \u2014 the router: the mental model, the deploy contract, every gotcha, and control flow. Read it in full first; it ends with a list of topic files and the condition for opening each.
-- \`node_modules/@xanots/sdk/llms/*.md\` \u2014 one file per surface. Open the one or two whose condition matches the task; skip the rest.
-- The published TypeScript types and JSDoc (\`node_modules/@xanots/sdk/**/*.d.ts\`).
-- \`node_modules/@xanots/sdk/manifest.json\` \u2014 the exhaustive reference; grep or \`jq\` the one entry you need rather than reading it whole.
-
-Author against those signatures \u2014 don't invent an API that isn't there.
-
-## The shape
-
-\`\`\`
-xano/
-\u251C\u2500\u2500 index.ts          default export: the workspace registering everything below
-\u251C\u2500\u2500 tables/<name>.ts  a table (name, typed schema, indexes)
-\u251C\u2500\u2500 api/<group>.ts    an API group; pin its canonical slug so paths are stable
-\u2514\u2500\u2500 api/<endpoint>.ts a query: name, verb, apiGroup, typed input, a stack, a response
-\`\`\`
-
-## Steps
-
-1. **Define a table** under \`tables/\` with \`table({ name, schema: { ... } })\`.
-   \`id\` and \`created_at\` are auto-injected.
-2. **Define an API group** with \`apiGroup({ name, canonical })\`. Pinning the
-   canonical slug keeps the public path stable and lets \`getPath()\` resolve in
-   the browser bundle without a lock file.
-3. **Define endpoints** with \`query({ name, verb, apiGroup, input, ... })\`, building
-   the logic from the \`s.*\` statement helpers and the expression/column/input/
-   reference helpers.
-4. **Register everything** in \`index.ts\`:
-   \`\`\`ts
-   export default workspace("${appName}")
-     .registerTables([...])
-     .registerApiGroups([...])
-     .registerQueries([...]);
-   \`\`\`
-5. **Assert it works** \u2014 add a \`tests: [...]\` entry to a query or function
-   (named inputs plus \`expect.*\` assertions on its response), or a
-   \`workflowTest({ name, stack })\` when the behavior spans several objects.
-   They live beside the code they cover and ship with it. See "Testing" below.
-6. **Compile** with \`npm run xano:export\`, and **deploy** with
-   \`npm run xano:deploy\` (after \`xanots login\`). The first of either writes
-   \`xano/xano.lock\` \u2014 **commit it**. It pins every object's identity, so a later
-   rename renames the object instead of deleting and recreating it. See
-   "\`xano.lock\` \u2014 commit it" in the project README.
-
-## Testing
-
-Two kinds of test are authored in \`xano/\` alongside the objects they cover, and
-both run against a DEPLOYED environment:
-
-- **Unit test** \u2014 \`tests: [...]\` on a \`query\`, \`defineFunction\`, or
-  \`middleware\`. Each entry is a named set of inputs run against that object, with
-  \`expect.*\` assertions on its response. A statement's \`mock\` (keyed by test
-  NAME) makes one step return a value instead of doing its work, but only while
-  that test runs.
-- **Workflow test** \u2014 \`workflowTest({ name, stack })\`, a standalone object whose
-  stack calls others (\`s.function.call\`, \`s.api.call\`) and asserts with
-  \`s.expect.*\`. Use it for behavior that spans objects.
-
-\`expect.*\` and \`s.expect.*\` are different builders \u2014 an assertion record versus
-a workflow-test statement \u2014 and are not interchangeable.
-
-\`\`\`bash
-npm run xano:deploy    # tests run against what is deployed, so deploy first
-npm run xano:test      # runs both kinds; exits 5 if any fail
-\`\`\`
-
-\`npx xanots deploy ./xano/index.ts --test\` does both in one step, and
-\`npx xanots test list\` shows what a deployed environment carries without running
-anything. Read \`node_modules/@xanots/sdk/llms/tests.md\` before authoring either
-kind.
-
-### Event-driven objects
-
-A scheduled \`task\`, an \`mcpServer\`, and every trigger **fire normally on an
-ephemeral** \u2014 where \`deploy\` sends them \u2014 so test them by deploying and letting
-them run.
-
-## Wire the frontend
-
-In [\`../frontend/src/lib/api.ts\`](../frontend/src/lib/api.ts), derive paths and
-types from your query defs (\`getPath()\`, \`InferInput\`, \`InferResponse\`) \u2014 never
-hand-type a URL or a request body.
-
-Keep the client bundle lean (**split route metadata from stack-heavy authoring**):
-
-- \`import type\` for shapes \u2014 \`InferInput\`/\`InferResponse\` erase to nothing.
-- Import the **one lean query def** for its \`getPath()\`/\`verb\`, never \`xano/index.ts\`
-  (that pulls the whole workspace). A def's \`s.*\`/\`c.*\` stack calls run at module
-  load to build it, so they can't be tree-shaken out of the bundle.
-- A def whose stack builds a heavy graph \u2014 an agent + its tools via \`s.ai.agent.run\`
-  \u2014 drags that whole graph in. For those, don't import the def in the browser:
-  declare its \`{ path, verb }\` as plain metadata (see the \`ROUTES\` example in
-  \`api.ts\`) and verify it against the compiled bundle with
-  \`npx xanots routes xano/index.ts\`.
-`;
-}
-function describeOrigin(o) {
-  switch (o.source) {
-    case "workspace":
-      return `workspace ${o.origin}`;
-    case "ephemeral":
-      return `ephemeral "${o.origin}"`;
-    case "file":
-      return `the bundle at ${o.origin}`;
-  }
-}
-function renderCodegenMarker({ sdkVersion }, origin, generatedAt, report) {
-  return JSON.stringify(
-    {
-      source: origin.source,
-      origin: origin.origin,
-      sdkVersion,
-      generatedAt,
-      note: "Written by `xanots init --from`. Its presence lets a re-run refresh xano/ in place.",
-      // The findings, so parity is trackable release over release and gateable
-      // in CI without scraping stderr. Omitted rather than written empty when
-      // the caller has none to record.
-      ...report === void 0 ? {} : { report }
-    },
-    null,
-    2
-  ) + "\n";
-}
-function renderCodegenReadme({ appName }, origin, envNames, preset) {
-  const secrets = envNames.length === 0 ? "" : `
-## Heads up: this tree contains your workspace env var values
-
-The pull carried ${envNames.length} workspace env var${envNames.length === 1 ? "" : "s"} \u2014
-${envNames.map((n) => `\`${n}\``).join(", ")} \u2014 **with their values**, inline in
-[\`xano/index.ts\`](xano/index.ts), because that is what a deploy has to send. If any of them
-is a secret, do not commit \`xano/\` as-is: add it to \`.gitignore\`, or replace the values
-before committing.
-`;
-  return `# ${appName}
-
-A [XanoTS](https://www.npmjs.com/package/@xanots/sdk) project pulled from
-${describeOrigin(origin)}. The Xano backend lives in [\`xano/\`](xano/) as readable
-TypeScript; the ${preset.label} frontend under [\`frontend/\`](frontend/) is a starter \u2014
-the pull carries a backend, not a UI.
-
-## Deploy it
-
-\`\`\`bash
-xanots login            # once, to authenticate against your Xano account
-npm run xano:deploy     # typecheck, build the frontend, ship both
-\`\`\`
-
-## Read this before deploying
-
-- **\`xano/\` is disposable.** Re-running \`xanots init --from\` on this directory
-  rewrites it wholesale \u2014 no merge, no diff, no preservation of hand edits. The rest of
-  the project (this README, \`package.json\`, \`frontend/\`) is yours and is left alone.
-- **Deploying is a full replace.** The import path clears the target workspace and
-  re-imports. Send this only to an **ephemeral** environment \u2014 never to a
-  workspace holding data you care about. That is why \`npm run xano:deploy\` targets an
-  ephemeral env and there is no deploy-to-your-real-workspace command.
-- **This is schema only.** Table rows are not carried, and neither are payload sections
-  this SDK models no kind for. A deploy recreates the structure, not the data.
-
-[\`xano/README.md\`](xano/README.md) is the authoritative record of what did and did not
-translate cleanly on this pull. Read it before trusting the tree.
-${secrets}
-## Working on it
-
-\`\`\`bash
-npm run dev            # run the starter frontend
-npm run typecheck      # the whole project, both halves
-npm run xano:export    # compile the backend to workspace.json (don't commit it)
-npx xanots routes xano/index.ts   # list every endpoint's verb + path
-\`\`\`
-
-[\`frontend/src/lib/api.ts\`](frontend/src/lib/api.ts) shows the one contract: derive
-request paths and types from the query defs in \`xano/\` rather than hand-typing a URL.
-`;
-}
-function renderReadmeThemingSection(choice) {
-  const { theme, dark } = choice;
-  const darkNote = {
-    system: `Dark mode follows the OS. An inline script in the HTML entry sets
-\`class="dark"\` on \`<html>\` before first paint (so the page never flashes light
-first), and the \`.dark\` block in the stylesheet supplies the palette. To let
-people override it, add a control that toggles that class \u2014 or scaffold your
-next project with \`--dark toggle\`, which ships one.`,
-    toggle: `Dark mode follows the OS until the user says otherwise. The pieces:
-an inline script in the HTML entry applies the mode before first paint,
-[\`frontend/src/lib/theme.ts\`](frontend/src/lib/theme.ts) holds and persists it,
-and the mode toggle on the landing page cycles system \u2192 light \u2192 dark.`,
-    off: `This project was scaffolded with \`--dark off\`, so nothing switches
-themes. The \`.dark\` block in the stylesheet is still there and still complete \u2014
-add \`class="dark"\` to \`<html>\` to see it, and wire that to a control (or the OS
-setting) to turn it on for real.`
-  }[dark];
-  return `## Theming
-
-Scaffolded with the **${theme.label}** theme. Every color in the app comes from
-the semantic tokens at the top of
-[\`frontend/src/index.css\`](frontend/src/index.css) \u2014 \`--primary\`,
-\`--muted-foreground\`, \`--border\`, the \`--chart-*\` ramp, the \`--sidebar-*\` set \u2014
-and every shadcn component reads those names, so editing one value rebrands
-everything that uses it. Style with the token classes (\`bg-primary\`,
-\`text-muted-foreground\`) rather than raw palette classes like \`bg-gray-100\`, or
-the theme stops being one.
-
-Tailwind v4 has no \`tailwind.config.js\`; that stylesheet *is* the config.
-
-To swap the whole palette later:
-
-\`\`\`bash
-npx shadcn@latest add https://ui.shadcn.com/r/themes/stone.json   # or any registry theme
-\`\`\`
-
-${darkNote}`;
-}
-var UI_DOCS_CTA = {
-  label: "Browse UI components",
-  href: "https://ui.shadcn.com/docs/components"
-};
-function initLanding({ appName }) {
-  return {
-    title: appName,
-    lead: [
-      { text: "Your XanoTS project is ready. The backend lives in " },
-      { code: "xano/" },
-      { text: " and this frontend in " },
-      { code: "frontend/" },
-      { text: "." }
-    ],
-    steps: [
-      [
-        { text: "Author your first table + endpoint in " },
-        { code: "xano/index.ts" },
-        { text: " (see " },
-        { code: "xano/EXAMPLE.md" },
-        { text: ")." }
-      ],
-      [{ text: "Wire it into the UI from " }, { code: "frontend/src/lib/api.ts" }, { text: "." }],
-      [{ text: "Ship it: " }, { code: "npm run xano:deploy" }, { text: "." }]
-    ],
-    cta: UI_DOCS_CTA
-  };
-}
-function codegenLanding({ appName }, origin) {
-  return {
-    title: appName,
-    lead: [
-      { text: `This project was pulled from ${describeOrigin(origin)}. The backend lives in ` },
-      { code: "xano/" },
-      { text: " as readable TypeScript; this frontend is a starter." }
-    ],
-    steps: [
-      [
-        { text: "Read " },
-        { code: "xano/README.md" },
-        { text: " \u2014 what did and did not translate cleanly on the pull." }
-      ],
-      [
-        { text: "List the endpoints: " },
-        { code: "npx xanots routes xano/index.ts" },
-        { text: ", then wire them up in " },
-        { code: "frontend/src/lib/api.ts" },
-        { text: "." }
-      ],
-      [
-        { text: "Ship it: " },
-        { code: "npm run xano:deploy" },
-        { text: " (a full replace of an ephemeral env)." }
-      ]
-    ],
-    cta: UI_DOCS_CTA
-  };
-}
-function renderIndexCss(choice = defaultThemeChoice()) {
-  const { theme } = choice;
-  const colorMap = colorTokens(theme.light).map((token) => `  --color-${token}: var(--${token});`).join("\n");
-  const block = (vars) => orderedTokens(vars).map(([name, value]) => `  --${name}: ${value};`).join("\n");
-  const faces = fontImports(choice.fonts);
-  const fontVars = fontThemeVars(choice.fonts).map(([name, value]) => `  ${name}: ${value};`).join("\n");
-  const headingRule = choice.fonts?.heading === void 0 ? "" : `
-  h1,
-  h2,
-  h3,
-  h4,
-  h5,
-  h6 {
-    font-family: var(--font-heading);
-  }`;
-  return `${faces.length === 0 ? "" : faces.join("\n") + "\n"}@import "tailwindcss";
-@import "tw-animate-css";
-
-@custom-variant dark (&:is(.dark *));
-
-/* Map the tokens below into Tailwind's theme so \`bg-primary\` and friends
-   resolve. Tailwind v4 does this in CSS; there is no tailwind.config.js. */
-@theme inline {
-${colorMap}
-  --radius-sm: calc(var(--radius) - 4px);
-  --radius-md: calc(var(--radius) - 2px);
-  --radius-lg: var(--radius);
-  --radius-xl: calc(var(--radius) + 4px);${fontVars === "" ? "" : `
-${fontVars}`}
-}
-
-/* Theme: ${theme.label}. Rebrand here \u2014 these are the only colors the
-   components know about. Swap the whole palette for another shadcn theme with
-   \`npx shadcn@latest add <registry-theme-url>\`, or scaffold a different one
-   next time with \`xanots init --theme <base>-<accent>\`. */
-:root {
-${block(theme.light)}
-}
-
-${darkBlockComment(choice.dark)}
-.dark {
-${block(theme.dark)}
-}
-
-@layer base {
-  * {
-    @apply border-border outline-ring/50;
-  }
-  body {
-    @apply bg-background text-foreground;
-  }${headingRule}
-}
-`;
-}
-function darkBlockComment(dark) {
-  switch (dark) {
-    case "system":
-      return `/* Applied by the inline script in index.html, which follows the OS setting.
-   Add a control that toggles this class to let the user override it. */`;
-    case "toggle":
-      return `/* Applied by frontend/src/lib/theme.ts \u2014 the OS setting by default, and the
-   user's choice once they use the mode toggle. */`;
-    case "off":
-      return `/* Applied by adding \`class="dark"\` to <html> \u2014 wire that to a toggle if you
-   want one; this scaffold was created with --dark off, so nothing does yet. */`;
-  }
-}
-function renderThemeScript(dark) {
-  if (dark === "off") return "";
-  const resolve = dark === "toggle" ? `var stored = localStorage.getItem("theme");
-          var dark = stored === "dark" || (stored !== "light" && media.matches);` : `var dark = media.matches;`;
-  return `    <script>
-      // Sets the \`dark\` class before first paint, so the page never flashes
-      // light before switching. Keep this inline and above the stylesheet.
-      (function () {
-        try {
-          var media = window.matchMedia("(prefers-color-scheme: dark)");
-          ${resolve}
-          document.documentElement.classList.toggle("dark", dark);
-        } catch (e) {}
-      })();
-    </script>
-`;
-}
-function renderThemeModule() {
-  return `/**
- * Color mode, persisted. The inline script in index.html applies the stored
- * value before first paint; this module is what changes it afterwards.
- *
- * "system" means no stored preference \u2014 the OS decides, and keeps deciding if
- * the user changes it while the page is open.
- */
-export type Mode = "light" | "dark" | "system";
-
-const KEY = "theme";
-
-const prefersDark = () =>
-  window.matchMedia("(prefers-color-scheme: dark)").matches;
-
-/** The stored preference, or "system" when there is none. */
-export function getMode(): Mode {
-  const stored = localStorage.getItem(KEY);
-  return stored === "light" || stored === "dark" ? stored : "system";
-}
-
-/** Whether \`mode\` renders dark right now. */
-export function isDark(mode: Mode): boolean {
-  return mode === "dark" || (mode === "system" && prefersDark());
-}
-
-/** Persist a mode and apply it. "system" clears the stored override. */
-export function setMode(mode: Mode): void {
-  if (mode === "system") localStorage.removeItem(KEY);
-  else localStorage.setItem(KEY, mode);
-  document.documentElement.classList.toggle("dark", isDark(mode));
-}
-
-/**
- * Re-apply on OS changes, and on changes made in another tab. Returns an
- * unsubscribe function \u2014 call it from your framework's cleanup hook.
- *
- * The OS listener re-reads the mode rather than closing over it, so it stays
- * correct after the user picks an explicit light/dark and then goes back to
- * system.
- */
-export function watchMode(onChange: (mode: Mode) => void): () => void {
-  const media = window.matchMedia("(prefers-color-scheme: dark)");
-  const apply = () => {
-    const mode = getMode();
-    document.documentElement.classList.toggle("dark", isDark(mode));
-    onChange(mode);
-  };
-  media.addEventListener("change", apply);
-  window.addEventListener("storage", apply);
-  return () => {
-    media.removeEventListener("change", apply);
-    window.removeEventListener("storage", apply);
-  };
-}
-`;
-}
-function renderCnUtil(extra = "") {
-  return `import { clsx, type ClassValue } from "clsx";
-import { twMerge } from "tailwind-merge";
-
-export function cn(...inputs: ClassValue[]) {
-  return twMerge(clsx(inputs));
-}
-${extra}`;
-}
-function renderApiTs() {
-  return `// The one contract: derive paths and request/response *types* from your xanots
-// query defs. Never hand-type a URL or a request body \u2014 change a def and
-// everything here follows.
-//
-// Keep the client bundle lean (the split-route-metadata rule):
-//   \u2022 \`import type\` for shapes \u2014 InferInput/InferResponse erase to nothing.
-//   \u2022 Import the ONE lean query def module for its getPath()/verb \u2014 never
-//     ../../../xano/index.js (that pulls the whole workspace) and never a def
-//     whose stack builds a heavy graph (an agent + its tools via s.ai.agent.run):
-//     those s.*/c.* factory calls run at module load and can't be tree-shaken out.
-//   \u2022 For such a stack-heavy endpoint, don't import its def in the browser at all \u2014
-//     declare its { path, verb } in the ROUTES table below and verify it against
-//     the compiled bundle with \`npx xanots routes xano/index.ts\`.
-//
-// This starter has no endpoints yet. Once you add one in xano/, wire it like:
-//
-//   // Types are free \u2014 always import them type-only.
-//   import type { InferInput, InferResponse } from "@xanots/sdk";
-//   import type { createNoteQuery } from "../../../xano/api/create-note.js";
-//
-//   // Runtime path/verb: import the lean def value, OR (for a stack-heavy def)
-//   // read it from ROUTES so the def never enters the bundle.
-//   import { createNoteQuery } from "../../../xano/api/create-note.js";
-//
-//   export type CreateNoteBody = InferInput<typeof createNoteQuery>;
-//   export type Note = InferResponse<typeof createNoteQuery>;
-//
-//   export async function createNote(body: CreateNoteBody): Promise<Note> {
-//     const res = await fetch(XANO_HOST + createNoteQuery.getPath(), {
-//       method: createNoteQuery.verb,
-//       headers: { "content-type": "application/json" },
-//       body: JSON.stringify(body),
-//     });
-//     if (!res.ok) throw new Error(await res.text());
-//     return res.json();
-//   }
-//
-// The stack-heavy escape hatch \u2014 plain metadata, no def import, no bundle cost.
-// Keep it in sync with \`npx xanots routes xano/index.ts\` (it prints verb + path):
-//
-//   export const ROUTES = {
-//     triageRequest: { path: "/api:notes/triage_request", verb: "POST" },
-//   } as const;
-
-/**
- * The deployed Xano backend's base URL. Injected as \`window.XANO_HOST\` by
- * \`xanots deploy <entry> --static <dir>\`, or read from \`VITE_XANO_HOST\` in dev.
- * Empty string when neither is set (the UI runs with no backend).
- */
-export const XANO_HOST: string =
-  (typeof window !== "undefined" && (window as { XANO_HOST?: string }).XANO_HOST) ||
-  import.meta.env.VITE_XANO_HOST ||
-  "";
-`;
-}
-
-export {
-  sdkDep,
-  renderPackageJson,
-  renderTsconfig,
-  renderViteConfig,
-  renderIndexHtml,
-  renderGitignore,
-  renderEnvExample,
-  renderReadme,
-  renderXanoIndex,
-  renderXanoExampleMd,
-  describeOrigin,
-  renderCodegenMarker,
-  renderCodegenReadme,
-  initLanding,
-  codegenLanding,
-  renderIndexCss,
-  renderThemeScript,
-  renderThemeModule,
-  renderCnUtil,
-  renderApiTs
-};
-//# sourceMappingURL=chunk-ANUDXFEX.js.map