@xanots/sdk 0.0.1

package/dist/logout-command-MX3MJS5U.js

@@ -0,0 +1,68 @@
+import {
+  OpenIdProvider,
+  clearCredential,
+  globalAuthFilePath,
+  readCredential,
+  resolveAuthFilePath,
+  resolveScope
+} from "./chunk-7REDODS2.js";
+import {
+  detail,
+  hostLabel,
+  info,
+  success,
+  warn
+} from "./chunk-EZG76F7R.js";
+import "./chunk-GNPVYOPB.js";
+
+// src/emit/logout-command.ts
+async function runLogoutCommand(args) {
+  const authFilePath = resolveAuthFilePath(args, "write");
+  const targetsGlobal = authFilePath === globalAuthFilePath();
+  let saved;
+  try {
+    saved = readCredential(authFilePath);
+  } catch (err) {
+    warn(`Could not read ${authFilePath} (${err instanceof Error ? err.message : String(err)}).`);
+    if (clearCredential(authFilePath)) {
+      success("Removed the unreadable credential file.");
+      detail(`Removed ${authFilePath}`);
+    }
+    return;
+  }
+  if (!saved) {
+    info(`Not signed in (no credential at ${authFilePath}). Nothing to do.`);
+    return;
+  }
+  if (targetsGlobal) {
+    warn("Clearing the shared ~/.xanots credential \u2014 this affects every project that reuses it.");
+  }
+  if (saved.type === "token") {
+    clearCredential(authFilePath);
+    success(`Removed the meta API token credential for ${hostLabel(saved.instance_base_url)}`);
+    detail(`Removed ${authFilePath}`);
+    detail("The token itself is still valid \u2014 revoke it at its source if you need it dead.");
+    return;
+  }
+  if (saved.refresh_token) {
+    const provider = new OpenIdProvider({
+      authHost: saved.auth_host,
+      scope: saved.scope ?? resolveScope(args),
+      clientId: saved.client_id
+    });
+    try {
+      await provider.revoke(saved.refresh_token);
+    } catch (err) {
+      warn(
+        `Could not revoke the refresh token at ${hostLabel(saved.auth_host)} (${err instanceof Error ? err.message : String(err)}). Clearing local credentials anyway.`
+      );
+    }
+  }
+  clearCredential(authFilePath);
+  success(`Signed out of ${hostLabel(saved.instance)}`);
+  detail(`Removed ${authFilePath}`);
+}
+export {
+  runLogoutCommand
+};
+//# sourceMappingURL=logout-command-MX3MJS5U.js.map

package/dist/loop-OM3P2Z6O.js

@@ -0,0 +1,93 @@
+import {
+  ROUND_TRIP_KINDS,
+  indexByIdentity,
+  kindIsRunnable,
+  resolveMatch
+} from "./chunk-76QBEIGO.js";
+import {
+  normalize
+} from "./chunk-26CNBZE2.js";
+
+// src/validate/loop.ts
+async function runValidateLoop(client, bundleText) {
+  const bundle = JSON.parse(bundleText);
+  const payload = bundle.payload ?? {};
+  let imported;
+  try {
+    imported = await client.importBundle(bundleText);
+  } catch (err) {
+    return {
+      accepted: false,
+      importError: err instanceof Error ? err.message : String(err),
+      workspaceId: void 0,
+      roundTrip: [],
+      unchecked: []
+    };
+  }
+  const workspaceId = imported.workspaceId;
+  const present = ROUND_TRIP_KINDS.map((k) => ({ kind: k.key, compiled: asRecords(payload[k.key]) })).filter(
+    (p) => p.compiled.length > 0
+  );
+  if (workspaceId === void 0 || present.length === 0) {
+    return {
+      accepted: true,
+      workspaceId,
+      roundTrip: [],
+      unchecked: present.map((p) => ({ kind: p.kind, count: p.compiled.length }))
+    };
+  }
+  const exported = await client.exportWorkspace(workspaceId);
+  const roundTrip = [];
+  const unchecked = [];
+  for (const { kind, compiled } of present) {
+    const fetched = asRecords(exported.payload[kind]);
+    if (fetched.length === 0) {
+      unchecked.push({ kind, count: compiled.length });
+      continue;
+    }
+    const index = indexByIdentity(fetched);
+    for (const obj of compiled) {
+      const name = typeof obj.name === "string" ? obj.name : "(unnamed)";
+      const match = resolveMatch(obj, index);
+      if (match.outcome !== "found") {
+        roundTrip.push({ kind, name, status: match.outcome, diffs: [], fetched: void 0 });
+      } else {
+        const diffs = deepDiff(normalize(obj), normalize(match.fetched));
+        roundTrip.push({ kind, name, status: diffs.length === 0 ? "match" : "diff", diffs, fetched: match.fetched });
+      }
+    }
+  }
+  return { accepted: true, workspaceId, roundTrip, unchecked };
+}
+function runnableFunctionNames(entries) {
+  return entries.filter((e) => kindIsRunnable(e.kind) && (e.status === "match" || e.status === "diff")).map((e) => e.name);
+}
+function asRecords(v) {
+  return Array.isArray(v) ? v.filter((o) => o !== null && typeof o === "object") : [];
+}
+function deepDiff(expected, actual, path = "$") {
+  if (expected === actual) return [];
+  const bothObjects = expected !== null && actual !== null && typeof expected === "object" && typeof actual === "object";
+  if (!bothObjects) return [{ path, expected, actual }];
+  const expIsArr = Array.isArray(expected);
+  const actIsArr = Array.isArray(actual);
+  if (expIsArr !== actIsArr) return [{ path, expected, actual }];
+  if (expIsArr && actIsArr) {
+    const len = Math.max(expected.length, actual.length);
+    const out2 = [];
+    for (let i = 0; i < len; i++) out2.push(...deepDiff(expected[i], actual[i], `${path}[${i}]`));
+    return out2;
+  }
+  const e = expected;
+  const a = actual;
+  const keys = /* @__PURE__ */ new Set([...Object.keys(e), ...Object.keys(a)]);
+  const out = [];
+  for (const k of keys) out.push(...deepDiff(e[k], a[k], `${path}.${k}`));
+  return out;
+}
+export {
+  deepDiff,
+  runValidateLoop,
+  runnableFunctionNames
+};
+//# sourceMappingURL=loop-OM3P2Z6O.js.map

package/dist/marketplace-command-RATXTKXN.js

@@ -0,0 +1,379 @@
+import {
+  runNpm
+} from "./chunk-47WDWMBJ.js";
+import {
+  isMachineOutput,
+  writeJson
+} from "./chunk-NUQCEOKA.js";
+import {
+  serverMessage
+} from "./chunk-3IGNIP6R.js";
+import {
+  UsageError,
+  indentBlock,
+  missingArgument
+} from "./chunk-IZW6MK3U.js";
+import {
+  blank,
+  detail,
+  formatFields,
+  stdoutStyle,
+  step,
+  style,
+  success,
+  warn
+} from "./chunk-EZG76F7R.js";
+import "./chunk-YYRDLFSJ.js";
+
+// src/emit/marketplace-command.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+// src/emit/marketplace-catalogue.ts
+var DEFAULT_BASE_URL = "https://xare-rvr8-mnnt.dev.xano.io";
+var CATALOGUE_TIMEOUT_MS = 3e4;
+function baseUrl() {
+  const override = process.env.XANOTS_MARKETPLACE_URL;
+  return override !== void 0 && override !== "" ? override : DEFAULT_BASE_URL;
+}
+function asString(v) {
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+function asStringArray(v) {
+  return Array.isArray(v) ? v.filter((x) => typeof x === "string" && x !== "") : [];
+}
+function asBoolean(v) {
+  return typeof v === "boolean" ? v : void 0;
+}
+function asRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) ? v : void 0;
+}
+function projectRow(raw) {
+  return {
+    id: typeof raw.id === "number" ? raw.id : void 0,
+    slug: asString(raw.slug),
+    npm_package: asString(raw.npm_package),
+    title: asString(raw.title),
+    tagline: asString(raw.tagline),
+    tags: asStringArray(raw.tags),
+    repo_url: asString(raw.repo_url),
+    docs_url: asString(raw.docs_url)
+  };
+}
+function projectRequirements(v) {
+  if (!Array.isArray(v)) return [];
+  return v.map((entry) => typeof entry === "string" ? entry : asString(asRecord(entry)?.text)).filter((t) => t !== void 0);
+}
+function projectIncludes(v) {
+  if (!Array.isArray(v)) return [];
+  return v.flatMap((entry) => {
+    const rec = asRecord(entry);
+    if (rec === void 0) return [];
+    return [{ kind: asString(rec.kind), name: asString(rec.name), summary: asString(rec.summary) }];
+  });
+}
+function projectModule(raw) {
+  return {
+    ...projectRow(raw),
+    description: asString(raw.description),
+    includes: projectIncludes(raw.includes),
+    requirements: projectRequirements(raw.requirements),
+    register_snippet: asString(raw.register_snippet),
+    agent_prompt: asString(raw.agent_prompt),
+    listed: asBoolean(raw.listed),
+    deleted: asBoolean(raw.deleted)
+  };
+}
+var ModuleNotFoundError = class extends Error {
+  name = "ModuleNotFoundError";
+  constructor(message) {
+    super(message);
+  }
+};
+var CatalogueHttpError = class extends Error {
+  constructor(status, detail2, message) {
+    super(message);
+    this.status = status;
+    this.detail = detail2;
+  }
+  status;
+  detail;
+  name = "CatalogueHttpError";
+};
+async function read(path, params) {
+  let url;
+  try {
+    url = new URL(path, baseUrl());
+  } catch {
+    throw new Error(
+      `XANOTS_MARKETPLACE_URL is not a valid URL: ${JSON.stringify(process.env.XANOTS_MARKETPLACE_URL)}`
+    );
+  }
+  for (const [key, value] of Object.entries(params ?? {})) {
+    url.searchParams.set(key, value);
+  }
+  let res;
+  try {
+    res = await fetch(url.href, {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(CATALOGUE_TIMEOUT_MS)
+    });
+  } catch (err) {
+    throw new Error(
+      `Could not reach the marketplace catalogue at ${url.origin} \u2014 ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const text = await res.text();
+  if (!res.ok) {
+    const detail2 = serverMessage(text);
+    throw new CatalogueHttpError(
+      res.status,
+      detail2,
+      `The marketplace catalogue returned ${res.status} ${res.statusText} for ${url.pathname}` + (detail2 !== void 0 ? `:
+${detail2}` : ".")
+    );
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`Could not parse the ${url.pathname} response as JSON:
+${text}`);
+  }
+}
+function describe(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "an array";
+  if (typeof value === "object") {
+    const keys = Object.keys(value);
+    return `an object with keys ${keys.length > 0 ? keys.join(", ") : "(none)"}`;
+  }
+  return typeof value;
+}
+function expectArray(value, path) {
+  if (!Array.isArray(value)) {
+    throw new Error(`Expected ${path} to return a list of modules, got ${describe(value)}.`);
+  }
+  return value.flatMap((entry) => {
+    const rec = asRecord(entry);
+    return rec === void 0 ? [] : [rec];
+  });
+}
+async function fetchCatalogue() {
+  const path = "/api:marketplace/plugins";
+  return expectArray(await read(path), path).filter((raw) => raw.deleted !== true).map(projectRow);
+}
+async function searchCatalogue(query) {
+  const path = "/api:marketplace/plugins-search";
+  return expectArray(await read(path, { q: query }), path).map(projectRow);
+}
+async function fetchModule(pkg) {
+  const path = "/api:marketplace/plugins-details";
+  let body;
+  try {
+    body = await read(path, { package: pkg });
+  } catch (err) {
+    if (err instanceof CatalogueHttpError && err.status === 404) {
+      throw new ModuleNotFoundError(err.detail ?? "No module is published under that name.");
+    }
+    throw err;
+  }
+  if (body === null) {
+    throw new ModuleNotFoundError("No module is published under that name.");
+  }
+  const raw = asRecord(body);
+  if (raw === void 0) {
+    throw new Error(`Expected ${path} to return one module, got ${describe(body)}.`);
+  }
+  return projectModule(raw);
+}
+
+// src/emit/marketplace-command.ts
+function assertProjectDir(dir) {
+  const manifest = join(dir, "package.json");
+  if (!existsSync(manifest)) {
+    throw new Error(
+      `No package.json in ${dir} \u2014 \`xanots marketplace install\` runs inside a XanoTS project.
+  cd into your project first, or run \`xanots init\` to create one.`
+    );
+  }
+  try {
+    JSON.parse(readFileSync(manifest, "utf8"));
+  } catch (err) {
+    throw new Error(
+      `${manifest} is not valid JSON, so npm cannot install into it \u2014 fix it and re-run. (${err instanceof Error ? err.message : String(err)})`
+    );
+  }
+}
+function resolvePackage(args, verb = "install") {
+  const pkg = args.positionals[0];
+  if (pkg === void 0 || pkg === "") {
+    throw missingArgument("package", { command: "marketplace", subcommand: verb });
+  }
+  if (pkg.startsWith("-")) {
+    throw new UsageError(
+      verb === "install" ? `\`xanots marketplace install\`: "${pkg}" starts with a dash, so npm would read it as a flag, not a package.` : `\`xanots marketplace details\`: "${pkg}" starts with a dash, so it is a mistyped flag, not a package.`,
+      { helpFor: { command: "marketplace", subcommand: verb } }
+    );
+  }
+  return pkg;
+}
+async function runMarketplaceInstallCommand(args) {
+  refusePromptFlag(args, "install");
+  const pkg = resolvePackage(args);
+  const dir = process.cwd();
+  assertProjectDir(dir);
+  step(`Installing ${style.bold(pkg)}`);
+  const status = runNpm(["install", pkg], dir);
+  if (status !== 0) {
+    throw new Error(`npm install ${pkg} failed (exit ${status}).`);
+  }
+  blank();
+  success(`Installed ${pkg}.`);
+  detail(`Import it in your backend (\`xano/index.ts\`) and register it onto your workspace.`);
+}
+function refusePromptFlag(args, verb) {
+  if (!args.prompt) return;
+  throw new UsageError(
+    `\`xanots marketplace ${verb}\`: --prompt belongs to \`marketplace details <package>\`, which is the verb that has an agent prompt to print.`,
+    { helpFor: { command: "marketplace", subcommand: verb } }
+  );
+}
+function tagLine(tags) {
+  return tags.length > 0 ? tags.join(" \xB7 ") : void 0;
+}
+function renderRow(row) {
+  const s = stdoutStyle();
+  const name = row.npm_package ?? row.slug ?? "(unnamed)";
+  const title = row.title !== void 0 ? `  ${s.dim(row.title)}` : "";
+  const lines = [`  ${s.bold(s.cyan(name))}${title}`];
+  if (row.tagline !== void 0) lines.push(`    ${row.tagline}`);
+  const tags = tagLine(row.tags);
+  if (tags !== void 0) lines.push(`    ${s.dim(tags)}`);
+  if (row.docs_url !== void 0) lines.push(`    ${s.dim(row.docs_url)}`);
+  return lines.join("\n");
+}
+function writeRows(args, rows, empty) {
+  if (isMachineOutput(args)) {
+    writeJson(rows);
+    return;
+  }
+  const s = stdoutStyle();
+  if (rows.length === 0) {
+    process.stdout.write(`${empty}
+`);
+    return;
+  }
+  const count = `${rows.length} add-on${rows.length === 1 ? "" : "s"}`;
+  process.stdout.write(
+    `
+${s.dim(count)}
+
+` + rows.map(renderRow).join("\n\n") + `
+
+${s.dim("xanots marketplace details <package>  for what a module installs")}
+`
+  );
+}
+async function runMarketplaceListCommand(args) {
+  refusePromptFlag(args, "list");
+  writeRows(args, await fetchCatalogue(), "No add-ons are published yet.");
+}
+async function runMarketplaceSearchCommand(args) {
+  refusePromptFlag(args, "search");
+  const query = args.positionals[0];
+  if (query === void 0 || query === "") {
+    throw missingArgument("string", { command: "marketplace", subcommand: "search" });
+  }
+  const q = args.positionals.join(" ");
+  writeRows(
+    args,
+    await searchCatalogue(q),
+    `Nothing matched "${q}". Run \`xanots marketplace list\` to see everything.`
+  );
+}
+function renderModule(mod) {
+  const s = stdoutStyle();
+  const out = [];
+  const name = mod.npm_package ?? mod.slug ?? "(unnamed)";
+  out.push(`
+  ${s.bold(s.cyan(mod.title ?? name))}`);
+  if (mod.tagline !== void 0) out.push(`  ${mod.tagline}`);
+  if (mod.description !== void 0) {
+    out.push("");
+    out.push(s.dim(indentBlock(mod.description, "  ")));
+  }
+  out.push("");
+  const fields = [["Package", s.bold(name)]];
+  const tags = tagLine(mod.tags);
+  if (tags !== void 0) fields.push(["Tags", s.dim(tags)]);
+  if (mod.docs_url !== void 0) fields.push(["Docs", mod.docs_url]);
+  if (mod.repo_url !== void 0) fields.push(["Repo", mod.repo_url]);
+  out.push(formatFields(fields).trimEnd());
+  if (mod.includes.length > 0) {
+    out.push(`
+  ${s.bold("Installs")}`);
+    const width = Math.max(...mod.includes.map((i) => (i.kind ?? "").length));
+    for (const item of mod.includes) {
+      const kind = s.dim((item.kind ?? "").padEnd(width));
+      const summary = item.summary !== void 0 ? s.dim(` \u2014 ${item.summary}`) : "";
+      out.push(`    ${kind}  ${item.name ?? ""}${summary}`);
+    }
+  }
+  if (mod.requirements.length > 0) {
+    out.push(`
+  ${s.bold("You supply")}`);
+    for (const req of mod.requirements) out.push(`    \u2022 ${req}`);
+  }
+  if (mod.register_snippet !== void 0) {
+    out.push(`
+  ${s.bold("Register it")}`);
+    out.push(s.dim(indentBlock(mod.register_snippet, "    ")));
+  }
+  if (mod.npm_package !== void 0) {
+    out.push(`
+  ${s.bold(s.green(`xanots marketplace install ${mod.npm_package}`))}`);
+  }
+  if (mod.agent_prompt !== void 0) {
+    out.push(
+      `  ${s.dim(`xanots marketplace details ${name} --prompt  to hand the wiring to a coding agent`)}`
+    );
+  }
+  return out.join("\n") + "\n";
+}
+async function runMarketplaceDetailsCommand(args) {
+  const pkg = resolvePackage(args, "details");
+  let mod;
+  try {
+    mod = await fetchModule(pkg);
+  } catch (err) {
+    if (err instanceof ModuleNotFoundError) {
+      throw new Error(`${err.message} (looking for "${pkg}")
+  Try \`xanots marketplace search ${pkg}\`.`);
+    }
+    throw err;
+  }
+  if (mod.deleted === true) {
+    warn(`${mod.npm_package ?? pkg} has been removed from the marketplace.`);
+  }
+  if (args.prompt) {
+    if (mod.agent_prompt === void 0) {
+      throw new Error(
+        `${mod.npm_package ?? pkg} publishes no agent prompt. Run \`xanots marketplace details ${pkg}\` for its registration snippet instead.`
+      );
+    }
+    process.stdout.write(mod.agent_prompt + "\n");
+    return;
+  }
+  if (isMachineOutput(args)) {
+    writeJson(mod);
+    return;
+  }
+  process.stdout.write(renderModule(mod));
+}
+export {
+  runMarketplaceDetailsCommand,
+  runMarketplaceInstallCommand,
+  runMarketplaceListCommand,
+  runMarketplaceSearchCommand
+};
+//# sourceMappingURL=marketplace-command-RATXTKXN.js.map

package/dist/meta-client-OW5WKWW7.js

@@ -0,0 +1,170 @@
+import {
+  importWorkspaceArchive
+} from "./chunk-5WGEURVI.js";
+import {
+  createEphemeral,
+  deleteEphemeral,
+  isEphemeralDisabled,
+  waitUntilReady
+} from "./chunk-6DHBYBTO.js";
+import {
+  decodeWorkspaceArchive,
+  encodeWorkspaceArchive
+} from "./chunk-ZUTSMMAG.js";
+import "./chunk-X4DVXBFY.js";
+import "./chunk-3IGNIP6R.js";
+
+// src/validate/meta-client.ts
+var REQUEST_TIMEOUT_MS = 6e4;
+var ENV_WORKSPACE_ID = 1;
+var DEFAULT_PARENT_WORKSPACE_ID = 1;
+var ENV_EXPIRES_HOURS = 1;
+var MetaClient = class {
+  constructor(config) {
+    this.config = config;
+    this.readBase = config.instance;
+  }
+  config;
+  /**
+   * Origin that post-import reads/runs target. The objects land in this run's
+   * ephemeral ENVIRONMENT, served under a `/tenant/<slug>` path, so reads must hit
+   * that env-scoped origin rather than the parent instance — this is switched to
+   * the env URL after a successful import (and starts at the parent instance, which
+   * is what `verifyToken` and any pre-import call use).
+   */
+  readBase;
+  /** This run's ephemeral env, once created — the handle `dispose()` deletes. */
+  env;
+  /**
+   * The validate config as the deploy transports' `ResolvedAuth`. Validate is
+   * engineer tooling authenticated by a bare instance token from the environment,
+   * never the interactive OAuth store — hence `credentialType: "token"`.
+   */
+  deployAuth(workspaceId) {
+    return {
+      access_token: this.config.token,
+      instance: this.config.instance,
+      workspaceId,
+      credentialType: "token"
+    };
+  }
+  authHeaders() {
+    return { Authorization: `Bearer ${this.config.token}` };
+  }
+  /**
+   * Build a read/run URL against {@link readBase}, APPENDING the route so any
+   * `/tenant/<slug>` path prefix survives (a leading-slash `new URL(path, base)`
+   * would drop it back to the origin).
+   */
+  readUrl(path) {
+    return new URL(`${this.readBase}${path}`);
+  }
+  /**
+   * Create this run's ephemeral environment and import the compiled bundle into
+   * it, as the `gzip(tar(workspace.json))` archive.
+   *
+   * There is no `reset` knob: importing with a workspace id is ALWAYS a full
+   * replace, and the env is brand new besides. A flag that could not change the
+   * outcome would only invite the belief that a merge import exists here.
+   */
+  async importBundle(bundle) {
+    const parentWorkspaceId = this.config.workspaceId ?? DEFAULT_PARENT_WORKSPACE_ID;
+    const auth = this.deployAuth(parentWorkspaceId);
+    const env = await createEphemeral(auth, {
+      parentWorkspaceId,
+      display: "xanots-validate",
+      description: "Disposable environment for `xanots validate`.",
+      expiresHours: ENV_EXPIRES_HOURS
+    }).catch((err) => {
+      if (!isEphemeralDisabled(err)) throw err;
+      throw new Error(
+        "Ephemeral environments are not enabled on this instance, so `xanots validate` has nowhere disposable to run. Ask whoever administers the instance to enable them, or deploy to the sandbox and exercise the endpoints there (`xanots deploy --dest sandbox`)."
+      );
+    });
+    this.env = { parentWorkspaceId, name: env.name };
+    await waitUntilReady(auth, { parentWorkspaceId, name: env.name });
+    const envUrl = env.url;
+    if (envUrl === void 0 || envUrl === "") {
+      throw new Error(
+        `The validation environment (${env.name}) came back without a URL, so there is nothing to deploy into.`
+      );
+    }
+    const result = await importWorkspaceArchive(auth, {
+      baseUrl: envUrl,
+      archive: encodeWorkspaceArchive(bundle),
+      workspaceId: ENV_WORKSPACE_ID
+    });
+    this.readBase = envUrl.replace(/\/+$/, "");
+    return {
+      workspaceId: result.workspaceId ?? ENV_WORKSPACE_ID,
+      baseUrl: env.url,
+      raw: result.raw
+    };
+  }
+  /**
+   * Delete this run's ephemeral environment. Safe to call when no env was ever
+   * created, and never throws: a cleanup failure must not mask the validation
+   * result the caller is about to report. The env's own expiry is the backstop.
+   */
+  async dispose() {
+    const env = this.env;
+    if (env === void 0) return { deleted: false };
+    this.env = void 0;
+    try {
+      await deleteEphemeral(this.deployAuth(env.parentWorkspaceId), {
+        parentWorkspaceId: env.parentWorkspaceId,
+        name: env.name
+      });
+      return { deleted: true };
+    } catch (err) {
+      return { deleted: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  /**
+   * Export the workspace (this run's environment, post-import) as a `packageExport`
+   * bundle — the SAME shape the SDK emits, carrying full object logic. This is
+   * the faithful round-trip source: the response is a gzipped tar of
+   * `workspace.json`, decoded here into its bundle object.
+   */
+  async exportWorkspace(workspaceId) {
+    const url = this.readUrl(`/api:meta/workspace/${workspaceId}/export`);
+    const res = await fetch(url.href, {
+      method: "POST",
+      headers: { ...this.authHeaders(), "Content-Type": "application/json" },
+      body: JSON.stringify({ branch: "", password: "" }),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Export of workspace ${workspaceId} failed (${res.status} ${res.statusText}):
+${text}`);
+    }
+    const decoded = decodeWorkspaceArchive(new Uint8Array(await res.arrayBuffer()));
+    return { payload: decoded.payload ?? {} };
+  }
+  /**
+   * Run a named workspace function via the meta function-run route. Unlike the
+   * read methods this returns the status (rather than throwing) so a caller can
+   * report an engine error + logs as a runtime outcome.
+   */
+  async runFunction(workspaceId, name, input) {
+    const url = this.readUrl(`/api:meta/workspace/${workspaceId}/function/run`);
+    const res = await fetch(url.href, {
+      method: "POST",
+      headers: { ...this.authHeaders(), "Content-Type": "application/json" },
+      body: JSON.stringify({ name, input: input ?? {} }),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+    const text = await res.text();
+    let body = text;
+    try {
+      body = text === "" ? void 0 : JSON.parse(text);
+    } catch {
+    }
+    return { status: res.status, ok: res.ok, body };
+  }
+};
+export {
+  MetaClient
+};
+//# sourceMappingURL=meta-client-OW5WKWW7.js.map