@xanots/sdk 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Xano, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,384 @@
+<div align="center">
+
+# XanoTS
+
+### The official TypeScript SDK for [Xano](https://xano.com).
+
+**Write your app in TypeScript — the database, the APIs, even AI agents. Or let an
+AI write it for you. Then run one command and it's live on Xano's cloud, with its own
+URL. No servers, no setup, no config. That's it.**
+
+[![npm](https://img.shields.io/npm/v/@xanots/sdk?color=%230055FF&label=%40xanots%2Fsdk)](https://www.npmjs.com/package/@xanots/sdk)
+[![node](https://img.shields.io/node/v/@xanots/sdk)](https://nodejs.org)
+[![license](https://img.shields.io/npm/l/@xanots/sdk)](LICENSE)
+
+</div>
+
+```bash
+npx @xanots/sdk login                      # 1. sign in (opens your browser)
+npx @xanots/sdk init my-app && cd my-app   # 2. scaffold your backend + frontend
+npm run build                               # 3. build your frontend → frontend/dist
+npx xanots deploy ./xano/index.ts --static ./frontend/dist   # 4. deploy both → live URLs
+```
+
+```
+→ Deploying ./xano/index.ts → new ephemeral "my-app"
+✓ Ephemeral e4f2-9ab1 deployed
+! New ephemeral URL:
+    https://e4f2-9ab1.xano.io                                     ← backend, live
+    Expires in 1h 0m
+✓ Static host deployed
+    https://my-app.xano.io                                        ← frontend, live
+```
+
+<div align="center">
+
+**From an empty folder to a live full-stack app.** `init` sets up your project — a
+TypeScript backend and a React or Svelte frontend. `npm run build` builds your frontend, then
+`deploy` puts both online and hands you a live URL. Change your code — yourself or with
+an AI — and deploy again; your app updates in seconds. No servers to set up, nothing to
+configure, no glue code between your backend and your frontend.
+
+[Why](#why-xanots) ·
+[Quickstart](#quickstart) ·
+[The model](#the-model) ·
+[Deploying](#deploying) ·
+[Type-safe frontend](#a-type-safe-frontend-for-free) ·
+[Reference](#reference)
+
+</div>
+
+---
+
+## Why XanoTS
+
+Xano gives you a genuinely scalable backend — Postgres, serverless functions, background
+tasks, realtime, MCP servers, AI agents — without you running a single server. XanoTS is
+Xano's **officially supported** TypeScript SDK, and it gives you that backend **as code you
+own**:
+
+- **📦 TypeScript is the source of truth.** Your whole workspace — tables, indexes, API
+  endpoints, functions, triggers, tasks, middleware, AI toolsets — is typed TS in your repo.
+  Version it, review it in PRs, diff it, roll it back. No more clicking through a dashboard
+  and hoping prod matches staging.
+
+- **🚀 Deploy is built in.** `xanots deploy` compiles your code and ships it to a live Xano
+  environment over an authenticated connection, then prints its URL. Backend **and** static
+  frontend in one command — no export/import dance, no upload script to maintain.
+
+- **⚡ Fast, safe iteration.** Ephemeral environments are disposable and auto-expiring, so
+  you rebuild as often as you like. Deploys are identity-stable: re-running never duplicates
+  objects, and with a committed `xano.lock` renames stay renames instead of
+  delete-and-recreate.
+
+- **🧩 The types flow to your frontend.** Import a `query()` def into your React/Svelte/Angular
+  app and get the endpoint path, HTTP verb, and a fully-typed request payload — with **zero
+  codegen**. Rename a column and every consumer lights up red.
+
+- **🤖 AI-first by design.** A deterministic, fully-typed authoring surface: an agent (or
+  you) emits well-typed TS that always compiles to a valid, importable workspace. It ships
+  with machine-readable grounding an agent reads instead of your source — see
+  [Coverage & agent grounding](https://github.com/xanots/sdk/blob/main/guides/coverage.md).
+
+---
+
+## Quickstart
+
+The four commands at the top of this page are the whole loop. Here they are one at a time.
+
+**1. Sign in.** OAuth in your browser — no API keys to copy around. The CLI refreshes tokens
+for you, and the target instance comes from your token rather than a flag.
+
+```bash
+npx @xanots/sdk login
+```
+
+**2. Scaffold.** `init` writes a complete project: a Vite frontend under `frontend/` (React
+19 + shadcn/ui by default, or SvelteKit with `--framework svelte`), a XanoTS backend under
+`xano/`, and the `xano:export` / `xano:deploy` scripts already wired.
+
+```bash
+npx @xanots/sdk init my-app && cd my-app
+npm run dev                       # the frontend runs immediately
+```
+
+The starter backend is empty but already compiles and deploys — grow it from the walkthrough
+in `xano/EXAMPLE.md`. For the flags, the two presets, and add-ons, see
+[The scaffolded project](https://github.com/xanots/sdk/blob/main/guides/scaffold.md).
+
+**3. Build the frontend.**
+
+```bash
+npm run build                     # → frontend/dist
+```
+
+**4. Deploy both.** One authenticated call ships your database schema, your APIs, your
+functions and triggers, **and** your compiled web app.
+
+```bash
+npx xanots deploy ./xano/index.ts --static ./frontend/dist
+```
+
+```
+→ Deploying ./xano/index.ts → new ephemeral "my-app"
+✓ Ephemeral e4f2-9ab1 deployed
+! New ephemeral URL:
+    https://e4f2-9ab1.xano.io                                         ← backend, live
+    Expires in 1h 0m
+✓ Config injected into 1 document: window.XANO_HOST                   ← backend URL, wired in
+✓ Static host deployed
+    https://my-app.xano.io                                            ← frontend, live
+✓ Frontend is live                                                    ← edge confirmed serving THIS build
+```
+
+That's the dev loop. Change your code and run step 4 again; the environment refreshes in
+seconds. The deploy bakes the backend URL into your build as `window.XANO_HOST`, so the
+frontend never needs to know it ahead of time — read it with a build-time fallback:
+
+```ts
+const HOST = (typeof window !== "undefined" && window.XANO_HOST) || import.meta.env.VITE_XANO_HOST;
+```
+
+> Deploying again keeps the **backend** URL; the **frontend** one changes, because a deploy
+> is a full replace and clears the environment's static hosting along with its workspace.
+> Hand out the URL from the latest run. [Signing in & deploying](https://github.com/xanots/sdk/blob/main/guides/deploying.md) covers
+> the injection rules, serving stored files, and headless CI runs.
+
+**Prefer to wire it by hand?** Skip `init` — `npm install @xanots/sdk`, write your workspace
+in `xano/index.ts`, and steps 1 and 4 are unchanged. The entry must be an ES module (XanoTS
+defs are ESM-only); on Node ≥ 22.6 a `.ts` entry loads natively, and older Node wants
+[`tsx`](https://tsx.is).
+
+---
+
+## The model
+
+You author declarative def-objects, register them on one `Xano` instance, and XanoTS
+compiles the whole thing into Xano's importable bundle.
+
+```ts
+import { workspace, table, query, apiGroup, f, s, ref, c, expr, col } from "@xanots/sdk";
+
+// A database table — `id` + `created_at` auto-inject, so declare only your own columns.
+const user = table({
+  name: "user",
+  auth: true,
+  schema: {
+    email: f.email({ required: true, methods: ["trim", "lower"] }),
+    name:  f.text(),
+  },
+});
+
+const post = table({
+  name: "post",
+  schema: {
+    title:     f.text({ required: true }),
+    body:      f.text(),
+    published: f.bool({ default: false }),
+    author:    f.tableRef(user),          // a real foreign key, type-checked
+  },
+});
+
+// A public API group + endpoint. This query def is also the contract your frontend imports.
+const blog = apiGroup({ name: "blog", canonical: "blog" });
+
+const listPosts = query({
+  verb: "GET",
+  apiGroup: blog,
+  name: "list_posts",
+  stack: [
+    s.db.query({ table: post, where: expr(col("published"), "=", c.bool(true)), as: "rows" }),
+  ],
+  response: ref("rows"),
+});
+
+export default workspace("blog")
+  .registerApiGroups([blog])
+  .registerTables([user, post])
+  .registerQueries([listPosts]);
+```
+
+Tab-complete `s.` to discover the entire statement catalog — `s.db.*`, `s.math.*`,
+`s.array.*`, `s.text.*`, `s.storage.*`, `s.api.*`, `s.cloud.*`, control flow, AI agent runs,
+and more. **All 214 engine statement surfaces are authorable** — every field name matches
+the Xano engine, and the output is proven byte-for-byte against the engine's own golden
+fixtures.
+
+Give a table a `seed` array and those rows ship into the database on deploy, so a fresh
+environment comes up with its lookup tables and fixtures already in place. Tables, fields,
+statements, values, inputs, and middleware are all in the
+[Authoring reference](https://github.com/xanots/sdk/blob/main/guides/authoring.md); every kind you can author is in
+[Object kinds](https://github.com/xanots/sdk/blob/main/guides/object-kinds.md).
+
+---
+
+## Deploying
+
+**Two targets**, so the dev loop and the production step stay distinct:
+
+| Command | Where it goes |
+|---|---|
+| `xanots deploy` | A disposable **ephemeral** environment (default) — create-or-refreshed each run, auto-expiring, with its own URL. `--dest sandbox` targets your throwaway singleton instead. |
+| `xanots release` | Your **main Xano instance** workspace — the production target. **Merges** by default: objects are updated in place or added, and your table data is never touched unless you ask. |
+
+Every `deploy` is a **full replace** of the disposable environment — always fresh, no merge
+mode, no flags to get wrong. A `release` is the opposite by design: it changes what your code
+defines and leaves the rest of the workspace, including every row in every table, alone. An
+unchanged project is a no-op, which makes `release` safe to run on a schedule or in CI on
+every merge.
+
+Anything destructive is **previewed first** — the CLI fetches the plan, prints what would
+change, and asks. `--yes` skips the prompt for CI but never skips the preview. Start with
+`xanots release ./xano/index.ts --dry-run` to see the plan without committing to it.
+
+> ⚠️ A deploy is a full replace of the target environment, **including its table records**,
+> before importing. The blast radius is your own disposable ephemeral or sandbox — but
+> anything you only ever created by hand in it is gone. That is exactly why production has a
+> separate `release` path.
+
+Every flag, the `--prune` rules, the identity model, and headless CI runs are in
+[Signing in & deploying](https://github.com/xanots/sdk/blob/main/guides/deploying.md). Environment management is
+`xanots ephemeral <list|get|delete|export>`.
+
+### Testing
+
+The tests you author — a `tests` entry on a query, function, or middleware, or a standalone
+`workflowTest()` — run against a deployed environment:
+
+```bash
+npx xanots test run-all                    # the ephemeral you last deployed to
+npx xanots test run-all --dest workspace   # or your real workspace (this only reads)
+```
+
+`xanots test list` shows what is there without running it, and `xanots test run "<name>"`
+runs one. A failing suite exits **5**, distinct from a crash, so CI can tell the two apart.
+To deploy and prove it in one step, `xanots deploy ./xano/index.ts --test` — a failing test
+exits 5 **without** retracting the deploy, so the environment is live either way.
+
+---
+
+## A type-safe frontend, for free
+
+Because your API is a typed def, the code that *calls* it can reuse that def instead of
+re-typing URLs and request bodies. Import the `query()` into your frontend:
+
+```ts
+import { listPosts } from "../xano/index.js";          // the same def you deployed
+import { post } from "../xano/tables.js";
+import type { InferRow } from "@xanots/sdk";
+
+const BASE = window.XANO_HOST;                         // injected by the deploy
+
+type Post = InferRow<typeof post>;                     // { id: number; created_at: number; title: string; … }
+
+async function fetchPosts(): Promise<Post[]> {
+  const res = await fetch(BASE + listPosts.getPath(), { method: listPosts.verb });
+  return res.json();                                   // typed end to end
+}
+```
+
+- **`listPosts.getPath()`** → the endpoint path, resolved from your code (or the frozen
+  `xano.lock`). No hardcoded strings. `{param}` segments fill from `getPath({ params })`,
+  percent-encoded.
+- **`listPosts.verb`** → the HTTP method, straight from the def.
+- **`InferInput<typeof someQuery>`** → the request-payload type, derived from a query's
+  `input` map at compile time. Required inputs are required keys; enums become literal
+  unions. **No codegen, always in sync.**
+- **`InferRow<typeof post>`** → the table's row type. Rename or retype a column and every
+  consumer breaks at compile time — exactly where you want it.
+- **`InferResponse<typeof someQuery>`** → the endpoint's **response** type, closing the round
+  trip. It auto-derives the common shapes with no codegen, mirroring the static walk the
+  engine itself does, and degrades to `unknown` in exactly the cases the engine cannot
+  resolve either — declare `responseShape` there.
+
+The `@xanots/sdk` entry has **zero Node dependencies**, so importing your workspace graph
+into a browser bundle just works. The `node:fs`-backed emitters live in the separate
+`@xanots/sdk/node` entry a frontend never pulls in.
+
+Importing a def carries the SDK runtime with it. When that matters, emit a route manifest
+instead — plain data plus one interpolator, importing nothing:
+
+```bash
+xanots paths ./xano/index.ts --emit xano/routes.gen.ts
+```
+
+Route names and their `{param}` keys are still checked at compile time, so a backend rename
+is a compile error rather than a 404. The measured bundle numbers, the full response-inference
+rules, endpoint-name constraints, and the realtime helpers are in
+[The typed frontend surface](https://github.com/xanots/sdk/blob/main/guides/typed-frontend.md).
+
+---
+
+## Already have a Xano workspace?
+
+`codegen` runs the loop the other way: it reads a workspace and writes it back out as
+readable XanoTS source — real `s.db.query(...)`, `f.email()`, typed defs — not a JSON dump.
+And not a loose pile of files either: you get the same runnable project `xanots init`
+scaffolds, with the pulled workspace filling `xano/`. So a pull deploys:
+
+```bash
+xanots workspace codegen my-app   # your real workspace (the one your login is scoped to)
+cd my-app
+npm run build
+npm run xano:deploy               # → a live ephemeral URL
+```
+
+The other three sources are the same command with a different origin — `xanots sandbox
+codegen`, `xanots ephemeral codegen`, and `xanots codegen ws.json` for a bundle already on
+disk (offline, no login).
+
+Object identities are preserved, so cross-references stay intact, and a statement this SDK
+does not model yet round-trips verbatim rather than breaking the pull. Then it checks its own
+work: the tree it just wrote is loaded, exported, and diffed against the workspace it came
+from, so "it compiled" and "it means the same thing" are separate claims and you get both.
+
+> ⚠️ **`xano/` is a scratch surface.** Regenerating rewrites it, it carries schema only — no
+> table rows — and deploying it is a *full replace* of the target. Pull from your real
+> workspace, edit, and `deploy` to a disposable ephemeral or sandbox. Workspace env var
+> **values** ride inline in `xano/workspace.ts`, so treat a pulled tree as secret-bearing
+> before you commit it.
+
+What the generated tree looks like, how faithful the pull is, and how to read its report are
+in [Pulling an existing workspace](https://github.com/xanots/sdk/blob/main/guides/codegen.md).
+
+---
+
+## Reference
+
+Every kind, statement, filter, and field type is typed, so your editor's autocomplete is
+the fastest lookup — tab-complete `s.`, `f.`, `c.`, `fl.`, `input.`. For the written
+reference, the guides carry the shape of a project and the behavior that will bite you:
+
+| Guide | What's in it |
+|---|---|
+| [Project structure](https://github.com/xanots/sdk/blob/main/guides/project-structure.md) | How a `xano/` project is laid out, and why registration is explicit |
+| [The scaffolded project](https://github.com/xanots/sdk/blob/main/guides/scaffold.md) | What `xanots init` writes, the two frontend presets, add-ons, SvelteKit rules |
+| [Object kinds](https://github.com/xanots/sdk/blob/main/guides/object-kinds.md) | Every authorable kind, and splitting a workspace across microservices |
+| [Authoring reference](https://github.com/xanots/sdk/blob/main/guides/authoring.md) | Tables and fields, statements, values, inputs, middleware, seed data |
+| [CLI](https://github.com/xanots/sdk/blob/main/guides/cli.md) | Every command, shell completion, and what failures look like |
+| [Signing in & deploying](https://github.com/xanots/sdk/blob/main/guides/deploying.md) | Auth, ephemerals, `--static`, releasing to production, `xanots validate` |
+| [Environment & identity](https://github.com/xanots/sdk/blob/main/guides/environment.md) | Every environment variable, and how `xano.lock` pins identity |
+| [The typed frontend surface](https://github.com/xanots/sdk/blob/main/guides/typed-frontend.md) | Path resolution, input/response inference, bundle cost, the route manifest |
+| [Pulling an existing workspace](https://github.com/xanots/sdk/blob/main/guides/codegen.md) | What `xanots codegen` writes, how faithful it is, and how to read its report |
+| [Coverage & agent grounding](https://github.com/xanots/sdk/blob/main/guides/coverage.md) | What is covered, what is out of scope, and the files agents read |
+
+The package also ships two machine-readable descriptions of the same surface, generated from
+the SDK's own sources so they cannot drift from it: `llms.txt` (the router — the mental model
+and the gotchas, plus a map of the `llms/*.md` topic files) and `manifest.json` (per-entry
+detail: field schemas with engine defaults, filter argument lists, stored-name mappings).
+Both are readable by people too.
+
+---
+
+<div align="center">
+
+**Write TypeScript. Run `xanots deploy`. See it live.**
+
+[npm](https://www.npmjs.com/package/@xanots/sdk) ·
+[GitHub](https://github.com/xanots/sdk) ·
+[Issues](https://github.com/xanots/sdk/issues) ·
+[`llms.txt`](llms.txt) — the agent-facing router, mapping the `llms/` topic files
+
+XanoTS is the official TypeScript SDK for [Xano](https://xano.com). MIT licensed.
+
+</div>

package/dist/agent-file-refresh-7XCACU34.js

@@ -0,0 +1,95 @@
+import {
+  AI_PRESETS,
+  CODEGEN_MARKER,
+  managedBlockVersion,
+  presetFilePath,
+  renderPreset,
+  upsertManagedBlock
+} from "./chunk-VKFQJEMW.js";
+import "./chunk-47WDWMBJ.js";
+import {
+  warn
+} from "./chunk-EZG76F7R.js";
+
+// src/emit/agent-file-refresh.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+var AGENT_ENV_VARS = [
+  "CLAUDECODE",
+  "CLAUDE_CODE",
+  "CURSOR_TRACE_ID",
+  "CURSOR_AGENT",
+  "CODEX_SANDBOX",
+  "AIDER_MODEL",
+  "GITHUB_COPILOT_AGENT"
+];
+function codingAgentDetected(env = process.env) {
+  return AGENT_ENV_VARS.some((name) => (env[name] ?? "") !== "");
+}
+var CI_ENV_VARS = [
+  "CI",
+  "GITHUB_ACTIONS",
+  "GITLAB_CI",
+  "BUILDKITE",
+  "TEAMCITY_VERSION"
+];
+function isCI(env = process.env) {
+  return CI_ENV_VARS.some((name) => (env[name] ?? "") !== "");
+}
+function guidanceModeFor(projectDir) {
+  return existsSync(join(projectDir, CODEGEN_MARKER)) ? "generated" : "authored";
+}
+function appNameFor(projectDir) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(projectDir, "package.json"), "utf8"));
+    if (typeof pkg.name === "string" && pkg.name.length > 0) return pkg.name;
+  } catch {
+  }
+  return basename(projectDir);
+}
+function refreshAgentFiles(opts) {
+  const env = opts.env ?? process.env;
+  if (isCI(env) || !codingAgentDetected(env)) return [];
+  const mode = opts.mode ?? guidanceModeFor(opts.projectDir);
+  const appName = opts.appName ?? appNameFor(opts.projectDir);
+  const managed = [];
+  for (const preset of AI_PRESETS) {
+    const path = presetFilePath(preset);
+    const absolute = join(opts.projectDir, path);
+    if (!existsSync(absolute)) continue;
+    try {
+      const existing = readFileSync(absolute, "utf8");
+      const version = managedBlockVersion(existing);
+      if (version === null) continue;
+      managed.push({ preset, path, existing, version });
+    } catch (err) {
+      warn(`could not read ${path}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const selected = managed.map((m) => m.preset);
+  const refreshed = [];
+  for (const { preset, path, existing, version } of managed) {
+    const absolute = join(opts.projectDir, path);
+    try {
+      if (version === opts.sdkVersion) continue;
+      const rendered = renderPreset(preset, appName, mode, {
+        selected,
+        version: opts.sdkVersion
+      });
+      const updated = upsertManagedBlock(existing, rendered);
+      if (updated === existing) continue;
+      writeFileSync(absolute, updated);
+      refreshed.push(path);
+    } catch (err) {
+      warn(`could not refresh ${path}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return refreshed;
+}
+export {
+  CI_ENV_VARS,
+  codingAgentDetected,
+  isCI,
+  refreshAgentFiles
+};
+//# sourceMappingURL=agent-file-refresh-7XCACU34.js.map

package/dist/bin.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+import {
+  readVersion,
+  run
+} from "./chunk-YGPIY3WT.js";
+import {
+  exitCodeOf,
+  reportFailure
+} from "./chunk-IZW6MK3U.js";
+import {
+  blank,
+  clearProgress,
+  detail,
+  error,
+  style,
+  warn
+} from "./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 {
+  atomicWrite
+} from "./chunk-GNPVYOPB.js";
+import "./chunk-4HT3BNZ7.js";
+
+// src/emit/update-check.ts
+import { existsSync, readFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { createRequire } from "module";
+function registryUrl() {
+  return process.env.XANOTS_UPDATE_REGISTRY ?? "https://registry.npmjs.org/@xanots/sdk/latest";
+}
+function cachePath() {
+  return process.env.XANOTS_UPDATE_CACHE ?? join(homedir(), ".xanots", "update-check.json");
+}
+var CHECK_INTERVAL_MS = 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 2e3;
+function isNewer(candidate, current) {
+  const a = parseSemver(candidate);
+  const b = parseSemver(current);
+  if (!a || !b) return false;
+  for (let i = 0; i < 3; i++) {
+    if (a.nums[i] !== b.nums[i]) return a.nums[i] > b.nums[i];
+  }
+  if (a.pre.length === 0) return b.pre.length > 0;
+  if (b.pre.length === 0) return false;
+  return comparePre(a.pre, b.pre) > 0;
+}
+function parseSemver(v) {
+  const m = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(v.trim());
+  if (!m) return null;
+  return {
+    nums: [Number(m[1]), Number(m[2]), Number(m[3])],
+    pre: m[4] ? m[4].split(".") : []
+  };
+}
+function comparePre(a, b) {
+  const len = Math.max(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    if (i >= a.length) return -1;
+    if (i >= b.length) return 1;
+    const x = a[i];
+    const y = b[i];
+    const xn = /^\d+$/.test(x);
+    const yn = /^\d+$/.test(y);
+    if (xn && yn) {
+      if (Number(x) !== Number(y)) return Number(x) < Number(y) ? -1 : 1;
+    } else if (xn !== yn) {
+      return xn ? -1 : 1;
+    } else if (x !== y) {
+      return x < y ? -1 : 1;
+    }
+  }
+  return 0;
+}
+function readCache() {
+  const path = cachePath();
+  if (!existsSync(path)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof parsed.latest === "string" && typeof parsed.checkedAt === "number") {
+      return { latest: parsed.latest, checkedAt: parsed.checkedAt };
+    }
+  } catch {
+  }
+  return void 0;
+}
+function writeCache(cache) {
+  try {
+    const path = cachePath();
+    mkdirSync(dirname(path), { recursive: true });
+    atomicWrite(path, JSON.stringify(cache, null, 2) + "\n");
+  } catch {
+  }
+}
+async function fetchLatest() {
+  try {
+    const res = await fetch(registryUrl(), {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+function disabled() {
+  return Boolean(
+    process.env.XANOTS_NO_UPDATE_CHECK || process.env.NO_UPDATE_NOTIFIER || process.env.CI
+  );
+}
+async function resolveUpdateNotice(opts) {
+  if (!opts?.force && disabled()) return null;
+  const current = opts?.current ?? readVersion();
+  if (current === "unknown") return null;
+  const cache = readCache();
+  let latest = cache?.latest;
+  const now = Date.now();
+  if (!cache || now - cache.checkedAt > CHECK_INTERVAL_MS) {
+    const fetched = await fetchLatest();
+    if (fetched) {
+      latest = fetched;
+      writeCache({ latest: fetched, checkedAt: now });
+    }
+  }
+  return latest && isNewer(latest, current) ? { current, latest } : null;
+}
+function detectInstallMode() {
+  const override = process.env.XANOTS_INSTALL_MODE;
+  if (override === "global" || override === "local") return override;
+  try {
+    const requireFromCwd = createRequire(join(process.cwd(), "package.json"));
+    requireFromCwd.resolve("@xanots/sdk/package.json");
+    return "local";
+  } catch {
+    return "global";
+  }
+}
+function upgradeCommand(mode) {
+  return mode === "global" ? "npm i -g @xanots/sdk@latest" : "npm i -D @xanots/sdk@latest";
+}
+function printUpdateNotice(notice) {
+  blank();
+  warn(
+    `A new @xanots/sdk is available: ${style.dim(notice.current)} \u2192 ${style.green(notice.latest)}`
+  );
+  detail(`update: ${upgradeCommand(detectInstallMode())}`);
+}
+function runExitedClean(code = process.exitCode) {
+  return code === void 0 || code === 0;
+}
+async function maybeNotifyUpdate() {
+  try {
+    if (disabled() || process.stderr.isTTY !== true || !runExitedClean()) return;
+    const notice = await resolveUpdateNotice();
+    if (notice) printUpdateNotice(notice);
+  } catch {
+  }
+}
+
+// src/emit/interrupt.ts
+var EXIT_SIGINT = 130;
+function handleInterrupt(exit = process.exit) {
+  clearProgress();
+  error("Cancelled.");
+  exit(EXIT_SIGINT);
+}
+function installInterruptHandler() {
+  process.on("SIGINT", () => handleInterrupt());
+}
+
+// src/emit/bin.ts
+installInterruptHandler();
+run(process.argv.slice(2)).then(() => maybeNotifyUpdate()).catch((err) => {
+  reportFailure(err, readVersion());
+  process.exit(exitCodeOf(err));
+});
+//# sourceMappingURL=bin.js.map