@xanots/sdk 0.0.1

package/dist/chunk-YYRDLFSJ.js

@@ -0,0 +1,602 @@
+// src/emit/commands.ts
+function renderArgs(args) {
+  return (args ?? []).map((a) => a.required ? `<${a.name}>` : `[${a.name}]`).join(" ");
+}
+var HELP_GROUP_ORDER = [
+  "Author",
+  "Deploy",
+  "Pull",
+  "Environments",
+  "Account",
+  "Maintenance"
+];
+var FLAGS = {
+  out: { spec: "--out, -o <path>", summary: "Write the artifact to this path instead of stdout" },
+  lock: { spec: "--lock[=<path>]", summary: "Use (and create) xano.lock \u2014 default: beside the entry file" },
+  entry: {
+    spec: "--entry=<path>",
+    summary: "Workspace entry to resolve xano.lock beside (for lock subcommands that take no entry file)"
+  },
+  "frozen-lock": { spec: "--frozen-lock", summary: "CI guard: fail instead of changing the lock" },
+  strict: { spec: "--strict", summary: "Promote every export warning (data-losing shapes, unresolvable filters) to a hard failure" },
+  yes: { spec: "--yes, -y", summary: "Confirm a destructive action non-interactively" },
+  bundle: { spec: "--bundle <path>", summary: "Use an already-exported bundle instead of an entry file" },
+  reset: { spec: "--reset", summary: "Accepted but redundant \u2014 every deploy is a full replace" },
+  dest: {
+    spec: "--dest <ephemeral|sandbox>",
+    summary: "Which environment to import into (default: ephemeral)",
+    values: ["ephemeral", "sandbox"]
+  },
+  kind: {
+    spec: "--kind <unit|workflow>",
+    summary: "Only this test family (default: both)",
+    values: ["unit", "workflow"]
+  },
+  concurrency: {
+    spec: "--concurrency <n>",
+    summary: "Run this many tests at once (default: 1). Tests share the environment database, so raise it only when yours do not depend on shared state."
+  },
+  "expires-hours": { spec: "--expires-hours <n>", summary: "Ephemeral TTL at create time, 1\u201372 (default: 1)" },
+  static: { spec: "--static <dir>", summary: "Archive this built frontend and deploy it to the static host" },
+  "allow-seed-in-static": {
+    spec: "--allow-seed-in-static",
+    summary: "Publish the static build even if it contains non-public seed values"
+  },
+  "static-env": { spec: "--static-env KEY=VALUE", summary: "Public config baked in as window.<KEY> (repeatable; never secrets)" },
+  emit: {
+    spec: "--emit <path>",
+    summary: "Write a generated route + socket module there (plain data, no SDK import)"
+  },
+  "static-host": { spec: "--static-host <name>", summary: "Static-host name to deploy to (default: default)" },
+  "static-routing": {
+    spec: "--static-routing spa|multipage",
+    summary: "Override URL resolution (inferred from the bundle; rarely needed)"
+  },
+  test: {
+    spec: "--test",
+    summary: "After deploying, run the environment's tests; a failure exits 5 without retracting the deploy"
+  },
+  "no-verify": { spec: "--no-verify", summary: "Skip the post-deploy liveness checks (static host, microservices); on the codegen commands it skips the offline round-trip check instead" },
+  "require-microservices": {
+    spec: "--require-microservices",
+    summary: "Fail the deploy (exit 4) when a microservice is not ready by the end of the wait"
+  },
+  report: {
+    spec: "--report <grouped|full|json>",
+    summary: "Findings as grouped root causes (default), every site, or JSON",
+    values: ["grouped", "full", "json"]
+  },
+  origin: { spec: "--origin <origin>", summary: "Xano control-plane OAuth host (default: $XANO_ORIGIN)" },
+  config: { spec: "--config <path>", summary: "Explicit credential file (default: $XANO_CONFIG)" },
+  local: { spec: "--local", summary: "Use the project-local ./.xano/auth.json instead of the shared cache" },
+  "all-workspaces": { spec: "--all-workspaces", summary: "Enumerate across every workspace, not just the token's" },
+  guest: { spec: "--guest, -g", summary: "Mint a read-only guest session (browse only)" },
+  "url-only": { spec: "--url-only, -u", summary: "Print the dashboard URL instead of opening a browser" },
+  prompt: { spec: "--prompt", summary: "Print only the add-on wiring prompt, for piping to a coding agent" },
+  port: { spec: "--port <n>", summary: "Fixed loopback callback port (default: ephemeral)" },
+  scope: { spec: '--scope "<list>"', summary: "OAuth scopes to request (default: the built-in set)" },
+  runtime: { spec: "--runtime", summary: "After the round-trip, run each deployed function and report" },
+  capture: { spec: "--capture", summary: "Write each round-tripped function's fetched JSON" },
+  verbose: { spec: "--verbose", summary: "Print full diffs and raw engine detail" },
+  instance: { spec: "--instance <url>", summary: "Override XANO_VALIDATE_INSTANCE for this run" },
+  format: { spec: "--format <json|multidoc>", summary: "Which artifact to emit", values: ["json", "multidoc"] },
+  path: { spec: "--path <p>", summary: "Output location \u2014 `-` for stdout, a dir, or a file path" },
+  name: { spec: "--name <n>", summary: "Name for what this command produces" },
+  framework: {
+    spec: "--framework <id>",
+    summary: "Frontend framework to scaffold: react (default), svelte",
+    values: ["react", "svelte"]
+  },
+  ai: {
+    spec: "--ai <preset>",
+    summary: "AI instruction files to scaffold: claude, codex, cursor, none",
+    values: ["claude", "codex", "cursor", "none"]
+  },
+  force: { spec: "--force", summary: "Scaffold into a non-empty directory (overwriting our own files)" },
+  "no-install": { spec: "--no-install", summary: "Skip the post-scaffold npm install" },
+  "dry-run": { spec: "--dry-run", summary: "Print what would change and exit without sending it" },
+  prune: { spec: "--prune", summary: "Also delete workspace objects your project no longer defines" },
+  "reset-data": { spec: "--reset-data", summary: "Empty every table the bundle carries before importing" },
+  seed: { spec: "--seed", summary: "Write the bundle's table rows (off by default)" },
+  replace: { spec: "--replace", summary: "Wipe the workspace and import in its place, instead of merging" },
+  open: { spec: "--open", summary: "Open the deployed URL in your browser when it lands" },
+  // ── Global (accepted by every command; see GLOBAL_FLAGS) ───────────────
+  json: {
+    spec: "--json",
+    summary: "Force JSON on stdout (default: whenever stdout is not a terminal)"
+  },
+  help: { spec: "--help, -h", summary: "Show help for the command and exit" },
+  version: { spec: "--version, -v", summary: "Print the CLI version and exit" }
+};
+var GLOBAL_FLAGS = ["json", "help", "version"];
+var AUTH = ["origin", "config", "local"];
+var READ_DEST = {
+  key: "dest",
+  summary: "Which environment to read (default: ephemeral)",
+  values: ["ephemeral", "sandbox", "workspace"]
+};
+var TEST_ENV = {
+  key: "name",
+  summary: "Ephemeral env to target (default: the one this project last deployed to)"
+};
+var COMPILE = ["lock", "frozen-lock", "strict"];
+var SCAFFOLD = [
+  { key: "name", summary: "Project name (default: the target directory's basename)" },
+  "framework",
+  "ai",
+  "force",
+  "no-install"
+];
+var CODEGEN_NO_VERIFY = {
+  key: "no-verify",
+  summary: "Skip the offline round-trip check that the written tree re-exports (no network, no deploy)"
+};
+var COMMANDS = {
+  // ── Author ──────────────────────────────────────────────────────────────
+  compile: {
+    group: "Author",
+    display: "compile <file>",
+    // Says "single object def", not "workspace": this command takes ONE def and
+    // prints its JSON artifact. The old summary claimed a workspace and
+    // XanoScript, neither of which it does — and `compile` is the first command
+    // listed under Author, so it is the first thing tried on the scaffold entry
+    // (a workspace), which fails. `export` is the workspace command.
+    summary: "Type-check a single object def and print its JSON artifact",
+    args: [{ name: "file", required: true, path: true }],
+    flags: ["out", "lock"],
+    example: "xanots compile ./xano/query/public/health_GET.ts"
+  },
+  export: {
+    group: "Author",
+    display: "export <file>",
+    summary: "Compile and write the deployable JSON bundle",
+    args: [{ name: "file", required: true, path: true }],
+    flags: ["out", ...COMPILE],
+    example: "xanots export ./index.ts --out bundle.json"
+  },
+  paths: {
+    group: "Author",
+    display: "paths <file>",
+    summary: "List each query's verb + resolved api:<canonical>/<name>",
+    args: [{ name: "file", required: true, path: true }],
+    flags: ["lock", "emit", "strict"],
+    example: "xanots paths ./index.ts --emit xano/routes.gen.ts"
+  },
+  routes: {
+    group: "Author",
+    display: "routes <file>",
+    summary: "Alias for `paths`",
+    aliasOf: "paths",
+    args: [{ name: "file", required: true, path: true }],
+    flags: ["lock", "emit", "strict"]
+  },
+  init: {
+    group: "Author",
+    display: "init [dir]",
+    summary: "Scaffold a new XanoTS project",
+    args: [{ name: "dir", required: false, path: true }],
+    flags: [...SCAFFOLD],
+    example: "xanots init my-app --ai claude"
+  },
+  marketplace: {
+    group: "Author",
+    display: "marketplace <list|search|details|install>",
+    summary: "Find XanoTS add-on packages and add them to this project",
+    subcommands: {
+      // No apostrophes in any registry string: zsh completion single-quotes
+      // these, and the completion suite fails the whole script on an odd quote.
+      list: {
+        summary: "List every published add-on, newest first",
+        extraArgHint: "`list` prints the whole catalogue; `xanots marketplace search <string>` is the filter.",
+        example: "xanots marketplace list"
+      },
+      search: {
+        summary: "Search add-ons by keyword across name, tagline and description",
+        // Variadic: the handler joins every term into one phrase query, so
+        // `search ai agent` searches for "ai agent" rather than dropping "agent".
+        args: [{ name: "string", required: true, variadic: true }],
+        example: "xanots marketplace search auth"
+      },
+      details: {
+        summary: "Show what an add-on installs, what it needs, and how to register it",
+        args: [{ name: "package", required: true }],
+        flags: ["prompt"],
+        example: "xanots marketplace details @xanots/auth"
+      },
+      install: {
+        summary: "Install a package into the XanoTS project in the current directory",
+        args: [{ name: "package", required: true }],
+        example: "xanots marketplace install @xanots/auth"
+      }
+    }
+  },
+  // ── Deploy ──────────────────────────────────────────────────────────────
+  deploy: {
+    group: "Deploy",
+    display: "deploy <file>",
+    summary: "Ship to a live ephemeral env (or --dest sandbox) \u2192 URL",
+    args: [{ name: "file", required: true, path: true, satisfiedBy: ["bundle"] }],
+    flags: [
+      "dest",
+      "expires-hours",
+      { key: "name", summary: "Display name for the ephemeral env (default: the workspace name)" },
+      "bundle",
+      "static",
+      "static-host",
+      "static-routing",
+      "static-env",
+      "allow-seed-in-static",
+      "no-verify",
+      "require-microservices",
+      "test",
+      "open",
+      "reset",
+      ...COMPILE,
+      ...AUTH
+    ],
+    example: "xanots deploy ./index.ts --test"
+  },
+  release: {
+    group: "Deploy",
+    display: "release <file>",
+    summary: "Promote to your instance workspace (merges; never wipes data)",
+    args: [{ name: "file", required: true, path: true, satisfiedBy: ["bundle"] }],
+    flags: [
+      "bundle",
+      "dry-run",
+      "prune",
+      "reset-data",
+      "seed",
+      "replace",
+      "yes",
+      { key: "force", summary: "Skip the confirmation prompt (same as --yes)" },
+      "static",
+      "static-host",
+      "static-routing",
+      "static-env",
+      "allow-seed-in-static",
+      "no-verify",
+      ...COMPILE,
+      ...AUTH
+    ],
+    example: "xanots release ./index.ts --dry-run"
+  },
+  validate: {
+    group: "Deploy",
+    display: "validate <file>",
+    summary: "Deploy to a throwaway tenant and verify the round-trip",
+    args: [{ name: "file", required: true, path: true, satisfiedBy: ["bundle"] }],
+    flags: ["bundle", "runtime", "capture", "verbose", "instance", "out", ...COMPILE],
+    example: "xanots validate ./index.ts --runtime"
+  },
+  // ── Pull ────────────────────────────────────────────────────────────────
+  codegen: {
+    group: "Pull",
+    display: "codegen <bundle> <path>",
+    summary: "A bundle JSON file \u2192 a runnable XanoTS project (offline)",
+    args: [
+      { name: "bundle.json", required: true, path: true },
+      { name: "path", required: true, path: true }
+    ],
+    flags: [...SCAFFOLD, CODEGEN_NO_VERIFY],
+    example: "xanots codegen ./bundle.json ./app"
+  },
+  // ── Environments ────────────────────────────────────────────────────────
+  workspace: {
+    group: "Environments",
+    display: "workspace",
+    summary: "Read your real workspace \u2014 details, export, codegen",
+    subcommands: {
+      details: {
+        summary: "Which instance and workspace am I bound to?",
+        flags: [...AUTH],
+        example: "xanots workspace details"
+      },
+      export: {
+        summary: "Write its bundle JSON",
+        flags: ["path", { key: "name", summary: "Output basename (default: `workspace`)" }, ...AUTH],
+        example: "xanots workspace export --path -"
+      },
+      codegen: {
+        summary: "Decode it into a runnable XanoTS project",
+        args: [{ name: "path", required: true, path: true }],
+        flags: [...SCAFFOLD, CODEGEN_NO_VERIFY, "report", ...AUTH],
+        example: "xanots workspace codegen ./app",
+        group: "Pull",
+        display: "workspace codegen <path>",
+        groupSummary: "Your real workspace \u2192 a runnable XanoTS project"
+      },
+      deploy: {
+        summary: "Removed \u2014 XanoTS never writes back to your real workspace",
+        removed: "`xanots workspace deploy` does not exist \u2014 the only import path is a FULL REPLACE of the target workspace, so XanoTS never writes back to your real one. Use `xanots deploy` (`--dest ephemeral` by default, or `--dest sandbox`)."
+      }
+    }
+  },
+  ephemeral: {
+    group: "Environments",
+    display: "ephemeral",
+    summary: "Manage ephemeral envs \u2014 list, get, delete, export, codegen, impersonate",
+    subcommands: {
+      list: {
+        summary: "List the ephemeral envs under your workspace",
+        flags: ["all-workspaces", ...AUTH],
+        example: "xanots ephemeral list"
+      },
+      get: {
+        summary: "Show one env's URL, status, and expiry",
+        args: [{ name: "name", required: true }],
+        flags: [...AUTH]
+      },
+      delete: {
+        summary: "Tear an env down now instead of waiting for its TTL",
+        args: [{ name: "name", required: true }],
+        flags: ["yes", { key: "force", summary: "Skip the destroy-this-env confirmation (same as --yes)" }, ...AUTH]
+      },
+      export: {
+        summary: "Write an env's bundle JSON",
+        args: [{ name: "name", required: true }],
+        flags: ["format", "path", { key: "name", summary: "Output basename (default: the env name)" }, ...AUTH]
+      },
+      codegen: {
+        summary: "Decode an env into a runnable XanoTS project",
+        args: [
+          { name: "name", required: true },
+          { name: "path", required: true, path: true }
+        ],
+        flags: [...SCAFFOLD, CODEGEN_NO_VERIFY, "report", ...AUTH],
+        example: "xanots ephemeral codegen my-env ./app",
+        group: "Pull",
+        display: "ephemeral codegen <env> <path>",
+        groupSummary: "An ephemeral env \u2192 a runnable XanoTS project"
+      },
+      impersonate: {
+        summary: "Open the env's dashboard as a scoped session",
+        args: [{ name: "name", required: true }],
+        flags: ["guest", "url-only", ...AUTH]
+      }
+    }
+  },
+  sandbox: {
+    group: "Environments",
+    display: "sandbox",
+    summary: "Export, inspect, or codegen your throwaway sandbox",
+    subcommands: {
+      details: {
+        summary: "Print the sandbox tenant, headlined by its URL",
+        flags: [...AUTH],
+        example: "xanots sandbox details"
+      },
+      export: {
+        summary: "Write the sandbox workspace as JSON or multidoc XanoScript",
+        extraArgHint: "`sandbox export` takes no input; it exports what is CURRENTLY DEPLOYED to your sandbox. To compile a local workspace, use `xanots export <file>`.",
+        flags: ["format", "path", { key: "name", summary: "Output basename (default: `sandbox`)" }, "bundle", ...COMPILE, ...AUTH],
+        example: "xanots sandbox export --format multidoc"
+      },
+      codegen: {
+        summary: "Decode the sandbox into a runnable XanoTS project",
+        args: [{ name: "path", required: true, path: true }],
+        flags: [...SCAFFOLD, CODEGEN_NO_VERIFY, "report", ...AUTH],
+        example: "xanots sandbox codegen ./app",
+        group: "Pull",
+        display: "sandbox codegen <path>",
+        groupSummary: "Your sandbox \u2192 a runnable XanoTS project"
+      },
+      deploy: {
+        summary: "Removed \u2014 unified under `xanots deploy --dest sandbox`",
+        removed: "`xanots sandbox deploy` was removed \u2014 use `xanots deploy --dest sandbox` (same behavior against the singleton sandbox, unified under `deploy`)."
+      }
+    }
+  },
+  test: {
+    group: "Environments",
+    display: "test",
+    summary: "Run the unit and workflow tests an environment carries",
+    subcommands: {
+      list: {
+        summary: "List the tests in an environment, without running any",
+        flags: [READ_DEST, TEST_ENV, "kind", ...AUTH],
+        example: "xanots test list --dest sandbox"
+      },
+      run: {
+        summary: "Run one test by name",
+        args: [{ name: "name", required: true }],
+        flags: [READ_DEST, TEST_ENV, ...AUTH],
+        example: 'xanots test run "happy path" --dest sandbox'
+      },
+      "run-all": {
+        summary: "Run every test in an environment and report pass/fail",
+        flags: [READ_DEST, TEST_ENV, "kind", "concurrency", ...AUTH],
+        example: "xanots test run-all --dest sandbox"
+      }
+    }
+  },
+  // ── Account ─────────────────────────────────────────────────────────────
+  login: {
+    group: "Account",
+    display: "login",
+    summary: "OAuth sign-in \u2014 shared cache, or --local per project",
+    flags: [
+      "local",
+      "port",
+      "scope",
+      "origin",
+      "config",
+      { key: "force", summary: "Sign in again even when a credential is already cached" }
+    ],
+    example: "xanots login --local"
+  },
+  logout: {
+    group: "Account",
+    display: "logout",
+    summary: "Revoke the refresh token and clear the cache",
+    flags: ["local", "origin", "config"]
+  },
+  profile: {
+    group: "Account",
+    display: "profile me",
+    summary: "Show the signed-in user and instance URL",
+    subcommands: {
+      me: {
+        summary: "Print the scoped user and the instance URL",
+        flags: [...AUTH],
+        example: "xanots profile me"
+      }
+    }
+  },
+  whoami: {
+    group: "Account",
+    display: "whoami",
+    summary: "Alias for `profile me`",
+    aliasOf: "profile me",
+    flags: [...AUTH],
+    example: "xanots whoami"
+  },
+  // ── Maintenance ─────────────────────────────────────────────────────────
+  lock: {
+    group: "Maintenance",
+    display: "lock",
+    summary: "Maintain xano.lock identities \u2014 rename, prune, adopt",
+    subcommands: {
+      rename: {
+        summary: "Move an entry keeping its identity, so the next export renames in place",
+        args: [
+          { name: "kind", required: true },
+          { name: "old", required: true },
+          { name: "new", required: true }
+        ],
+        flags: ["lock", "entry"],
+        example: "xanots lock rename --entry=xano/index.ts table users members"
+      },
+      prune: {
+        summary: "Drop orphaned entries (all, or just the named keys)",
+        args: [
+          { name: "entry-file", required: true, path: true, satisfiedBy: ["no-verify"] },
+          { name: "keys\u2026", required: false, variadic: true }
+        ],
+        flags: [
+          "yes",
+          "lock",
+          "entry",
+          {
+            key: "no-verify",
+            summary: "Prune the named keys without evaluating the entry file (identity only)"
+          }
+        ],
+        example: "xanots lock prune ./index.ts --yes"
+      },
+      adopt: {
+        summary: "Seed the lock from a live engine packageExport",
+        args: [{ name: "bundle.json", required: true, path: true }],
+        flags: ["yes", "lock", "entry"],
+        example: "xanots lock adopt ./packageExport.json --entry=xano/index.ts"
+      }
+    }
+  },
+  completion: {
+    group: "Maintenance",
+    display: "completion <shell>",
+    summary: "Print a shell completion script (bash, zsh, fish)",
+    args: [{ name: "shell", required: true, values: ["bash", "zsh", "fish"] }],
+    example: 'xanots completion zsh > "${fpath[1]}/_xanots"'
+  },
+  version: {
+    group: "Maintenance",
+    display: "version",
+    summary: "Print the CLI version"
+  },
+  help: {
+    group: "Maintenance",
+    display: "help",
+    summary: "Show this help",
+    // Variadic: a help target is a command PATH (`help workspace codegen`), and
+    // `resolveHelpRequest` reads it from the raw argv before any arity check.
+    args: [{ name: "command", required: false, variadic: true }],
+    example: "xanots help deploy"
+  },
+  // ── Removed (kept so the failure is explanatory, not a typo guess) ───────
+  push: {
+    group: "Deploy",
+    display: "push",
+    summary: "Removed \u2014 use `xanots deploy`",
+    removed: "`xanots push` was removed \u2014 use `xanots deploy` (`--dest ephemeral` by default, or `--dest sandbox`)."
+  }
+};
+function isCommand(name) {
+  return Object.hasOwn(COMMANDS, name);
+}
+function getCommand(name) {
+  return isCommand(name) ? COMMANDS[name] : void 0;
+}
+function getSubcommand(command, sub) {
+  const subs = getCommand(command)?.subcommands;
+  return subs && Object.hasOwn(subs, sub) ? subs[sub] : void 0;
+}
+function liveCommandNames() {
+  return Object.entries(COMMANDS).filter(([, spec]) => spec.removed === void 0 && spec.aliasOf === void 0).map(([name]) => name);
+}
+function flagNames() {
+  return Object.keys(FLAGS);
+}
+function flagKey(ref) {
+  return typeof ref === "string" ? ref : ref.key;
+}
+function flagSummary(ref) {
+  if (typeof ref !== "string") return ref.summary;
+  return FLAGS[ref].summary;
+}
+function flagValues(ref) {
+  if (typeof ref !== "string" && ref.values !== void 0) return ref.values;
+  return FLAGS[flagKey(ref)]?.values;
+}
+function liveSubcommandNames(command) {
+  const subs = getCommand(command)?.subcommands;
+  if (!subs) return [];
+  return Object.entries(subs).filter(([, spec]) => spec.removed === void 0).map(([name]) => name);
+}
+function distance(a, b) {
+  let row = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const next = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      next[j] = Math.min(next[j - 1] + 1, row[j] + 1, row[j - 1] + cost);
+    }
+    row = next;
+  }
+  return row[b.length];
+}
+function suggest(input, candidates) {
+  if (input === "") return void 0;
+  const lower = input.toLowerCase();
+  const prefix = candidates.filter((c) => c.startsWith(lower));
+  if (prefix.length === 1) return prefix[0];
+  let best;
+  let bestDistance = 3;
+  for (const c of candidates) {
+    const d = distance(lower, c);
+    if (d < bestDistance) {
+      bestDistance = d;
+      best = c;
+    }
+  }
+  return best;
+}
+
+export {
+  renderArgs,
+  HELP_GROUP_ORDER,
+  FLAGS,
+  GLOBAL_FLAGS,
+  COMMANDS,
+  isCommand,
+  getCommand,
+  getSubcommand,
+  liveCommandNames,
+  flagNames,
+  flagKey,
+  flagSummary,
+  flagValues,
+  liveSubcommandNames,
+  suggest
+};
+//# sourceMappingURL=chunk-YYRDLFSJ.js.map

package/dist/chunk-ZUTSMMAG.js

@@ -0,0 +1,46 @@
+import {
+  tarGz
+} from "./chunk-X4DVXBFY.js";
+
+// src/validate/archive.ts
+import { gunzipSync } from "zlib";
+function encodeWorkspaceArchive(workspaceJson, extra = []) {
+  return tarGz([
+    { name: "workspace.json", data: Buffer.from(workspaceJson, "utf8") },
+    ...extra.map((e) => ({ name: e.name, data: Buffer.from(e.content, "utf8") }))
+  ]);
+}
+function decodeWorkspaceArchive(data) {
+  let buf = Buffer.from(data);
+  let guard = 0;
+  while (buf.length > 2 && buf[0] === 31 && buf[1] === 139 && guard++ < 8) {
+    buf = gunzipSync(buf);
+  }
+  const files = readTar(buf);
+  const key = Object.keys(files).find((k) => k.endsWith("workspace.json"));
+  if (key === void 0) {
+    const seen = Object.keys(files).join(", ") || "none";
+    throw new Error(`Workspace export archive has no workspace.json (entries: ${seen}).`);
+  }
+  return JSON.parse(files[key].toString("utf8"));
+}
+function readTar(buf) {
+  const files = {};
+  let off = 0;
+  while (off + 512 <= buf.length) {
+    const name = buf.toString("utf8", off, off + 100).replace(/\0.*$/, "");
+    if (name === "") break;
+    const sizeField = buf.toString("utf8", off + 124, off + 136).replace(/\0.*$/, "").trim();
+    const size = parseInt(sizeField || "0", 8);
+    const start = off + 512;
+    if (Number.isFinite(size) && size > 0) files[name] = buf.subarray(start, start + size);
+    off = start + Math.ceil(size / 512) * 512;
+  }
+  return files;
+}
+
+export {
+  encodeWorkspaceArchive,
+  decodeWorkspaceArchive
+};
+//# sourceMappingURL=chunk-ZUTSMMAG.js.map