@lotics/cli 0.56.0 → 0.60.1

package/dist/src/cli.js

@@ -29579,6 +29579,8 @@ var require_lib3 = __commonJS({
 });
 
 // src/cli.ts
+import dns from "node:dns";
+import net2 from "node:net";
 import fs7 from "node:fs";
 import path6 from "node:path";
 import readline from "node:readline";
@@ -29586,6 +29588,19 @@ import readline from "node:readline";
 // src/client.ts
 import fs from "node:fs";
 import path from "node:path";
+function gatewayErrorMessage(status) {
+  if (status === 524) {
+    return "The request took too long to finish (gateway timeout). It may still be running \u2014 check back in a moment, or try again.";
+  }
+  if (status >= 500) {
+    return "The service is temporarily unavailable. Please try again shortly.";
+  }
+  return "The service returned an unexpected response. Please try again.";
+}
+function transportErrorMessage(status, parsed) {
+  const jsonMessage = parsed && typeof parsed.message === "string" ? parsed.message : null;
+  return parsed === null || status >= 500 || jsonMessage === null ? gatewayErrorMessage(status) : jsonMessage;
+}
 function findAvailableFilename(dir, filename, reserved) {
   const isTaken = (name) => {
     const full = path.join(dir, name);
@@ -29731,6 +29746,38 @@ var LoticsClient = class {
   async createApp(body) {
     return this.request("POST", "/v1/apps", body);
   }
+  /**
+   * Resolve the display name + fields (incl. select options) of the given tables
+   * — the schema `lotics app codegen` turns into the runtime `.lotics/app_fields.ts`
+   * alias maps. One `get_table` call per id (the tool surface has no batch
+   * variant); a missing/inaccessible table is dropped rather than throwing, so a
+   * stale id in the scope set never fails codegen.
+   */
+  async getWorkspaceSchema(tableIds) {
+    const tables = await Promise.all(
+      tableIds.map(async (table_id) => {
+        const res = await this.execute("get_table", { table_id });
+        if (res.error || res.result === null || typeof res.result !== "object") return null;
+        const table = res.result;
+        if (typeof table.id !== "string" || typeof table.name !== "string" || !Array.isArray(table.fields)) {
+          return null;
+        }
+        const fields = table.fields.flatMap((field) => {
+          if (field === null || typeof field !== "object") return [];
+          const f = field;
+          if (typeof f.key !== "string" || typeof f.name !== "string") return [];
+          const options = Array.isArray(f.options) ? f.options.flatMap((opt) => {
+            if (opt === null || typeof opt !== "object") return [];
+            const o = opt;
+            return typeof o.key === "string" && typeof o.name === "string" ? [{ id: o.key, label: o.name }] : [];
+          }) : void 0;
+          return [{ id: f.key, name: f.name, ...options && options.length > 0 ? { options } : {} }];
+        });
+        return { id: table.id, name: table.name, fields };
+      })
+    );
+    return tables.filter((t) => t !== null);
+  }
   /**
    * Rename an app's public subdomain — its `<slug>.lotics.app` address.
    * Mirrors PUT /v1/apps/{app_id}/subdomain. The old subdomain stops
@@ -29785,10 +29832,70 @@ var LoticsClient = class {
    * Mirrors POST /v1/apps/{app_id}/workflows/{alias}/execute.
    */
   async appWorkflow(app_id, alias, inputs) {
+    const url = `${this.baseUrl}/v1/apps/${encodeURIComponent(app_id)}/workflows/${encodeURIComponent(alias)}/execute`;
+    const headers = this.buildHeaders();
+    headers["Content-Type"] = "application/json";
+    let response;
+    try {
+      response = await fetch(url, { method: "POST", headers, body: JSON.stringify({ inputs }) });
+    } catch (err2) {
+      return { status: "error", message: err2 instanceof Error ? err2.message : "The workflow request failed." };
+    }
+    const text = await response.text();
+    let parsed = null;
+    if (text) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+      }
+    }
+    if (response.ok) return parsed ?? {};
+    return { status: "error", message: transportErrorMessage(response.status, parsed) };
+  }
+  /**
+   * Bind (create or replace) an app workflow by alias via the `set_app_workflow`
+   * tool — the SINGLE author of `apps.workflows` + the workflow row. `source` is
+   * the verbatim JS-subset body (no `on({...})` trigger). `inputs`/`outputs` are
+   * the typed schemas declared in `package.json#lotics.workflows.<alias>`. The
+   * server re-verifies the body and echoes the bound `outputs` (declared, else
+   * DERIVED from `return({ data })`), so the CLI can show the author what shape
+   * `result.data` will carry. Wraps the tool rather than a bespoke endpoint so
+   * the file flow stays a convenience over the existing single-author contract.
+   */
+  async setAppWorkflow(app_id, alias, body) {
+    return this.execute("set_app_workflow", {
+      app_id,
+      alias,
+      source: body.source,
+      ...body.inputs ? { inputs: body.inputs } : {},
+      ...body.outputs ? { outputs: body.outputs } : {},
+      ...body.name ? { name: body.name } : {},
+      ...body.description ? { description: body.description } : {}
+    });
+  }
+  /**
+   * Fetch one app workflow's faithful source + bound input/output schemas via
+   * `get_app_workflow`. `source` is the JS-subset body re-rendered from the
+   * persisted step tree (incl. the `return({ data })` clause, opaque field/option
+   * keys) — the exact text `lotics app workflow set` would push back. Feeds
+   * `lotics app pull`, which writes it to `src/workflows/<alias>.ts`.
+   */
+  async getAppWorkflow(app_id, alias) {
+    return this.execute("get_app_workflow", { app_id, alias });
+  }
+  /**
+   * Fetch the server-generated workspace `.d.ts` + the wrapper envelope that
+   * make a `src/workflows/<alias>.ts` body locally typecheckable (GAP-59).
+   * The server is the single source of the type model — the CLI never
+   * re-implements it. `envelope_prefix`/`envelope_suffix` are the exact
+   * `async function __workflow(): …` wrapper the server compiles inside, so the
+   * local typecheck mirrors the set-time verdict. Mirrors
+   * POST /v1/apps/{app_id}/workflows/{alias}/dts.
+   */
+  async getAppWorkflowDts(app_id, alias) {
     return this.request(
       "POST",
-      `/v1/apps/${encodeURIComponent(app_id)}/workflows/${encodeURIComponent(alias)}/execute`,
-      { inputs }
+      `/v1/apps/${encodeURIComponent(app_id)}/workflows/${encodeURIComponent(alias)}/dts`
     );
   }
   /**
@@ -30339,6 +30446,45 @@ function buildStarterTemplate(args) {
           // fall to `unknown`. The explicit glob makes the dot-dir the non-wildcard
           // base, which IS read. (GAP-38.)
           include: ["src", ".lotics/**/*"],
+          // src/workflows/<alias>.ts bodies run on the server (workflow globals:
+          // trigger / runtime / tool calls). They ARE locally typecheckable —
+          // each is wrapped in the server's `__workflow` envelope and references
+          // its per-alias `.lotics/workflows/<alias>.globals.d.ts` — but under a
+          // DEDICATED config that mirrors the server's compile options (es2022
+          // lib, NO DOM). The main `npm run typecheck` excludes them so it stays
+          // green and DOM-lib-free for bodies; check a body with
+          // `tsc -p tsconfig.workflows.json`. The server is the single verifier
+          // on `lotics app workflow set`.
+          exclude: ["node_modules", "src/workflows"]
+        },
+        null,
+        2
+      ) + "\n"
+    },
+    {
+      // Dedicated config for the editable workflow bodies (GAP-59). Mirrors the
+      // SERVER's set-time typecheck options (strict, lib es2022 with NO DOM,
+      // target ES2022, skipLibCheck) so a local `tsc -p tsconfig.workflows.json`
+      // gives the same verdict the server would on `lotics app workflow set`.
+      // Each body file is a module (the CLI writes a bookkeeping `export {};`),
+      // so the per-file `__workflow` wrapper doesn't collide across bodies.
+      path: "tsconfig.workflows.json",
+      content: JSON.stringify(
+        {
+          compilerOptions: {
+            target: "ES2022",
+            lib: ["ES2022"],
+            module: "ESNext",
+            moduleResolution: "Bundler",
+            strict: true,
+            skipLibCheck: true,
+            noEmit: true,
+            types: []
+          },
+          // The bodies + their per-alias ambient globals. `.lotics/workflows`
+          // uses the explicit `**/*` glob for the same dot-dir walk reason the
+          // main config does (TS's include walk skips bare dot-dirs).
+          include: ["src/workflows", ".lotics/workflows/**/*"],
           exclude: ["node_modules"]
         },
         null,
@@ -30678,6 +30824,60 @@ const routes = [
 export default function App() {
   return <AppRouter routes={routes} />;
 }
+`
+    },
+    {
+      // The home for editable workflow bodies. `lotics app pull` writes one
+      // `src/workflows/<alias>.ts` per bound workflow (faithful server source);
+      // edit it, then `lotics app workflow set <alias>` pushes it back through
+      // set_app_workflow (the server verifies). A new app has no bound workflows
+      // yet, so this is just the docked directory + the loop reference. It's a
+      // .md (not a .ts) so tsc's `include: ["src"]` never tries to compile it —
+      // a workflow body is a JS-subset expression over server globals
+      // (trigger / runtime / tool calls) that does NOT typecheck standalone.
+      path: "src/workflows/README.md",
+      content: `# Workflow bodies
+
+Editable JS-subset bodies of this app's workflows live here, one file per alias:
+\`src/workflows/<alias>.ts\`.
+
+## Loop
+
+\`\`\`bash
+lotics app workflow pull          # write/refresh every src/workflows/<alias>.ts from the server
+# edit src/workflows/<alias>.ts
+lotics app workflow set <alias>   # push it back through set_app_workflow (the server verifies)
+\`\`\`
+
+\`lotics app pull <app_id>\` also writes these files (alongside the rest of the project).
+
+## What a body is
+
+A workflow body is a **JS-subset expression** that runs server-side using workflow
+globals (\`trigger\`, \`runtime\`, tool calls) and ends with \`return({ data })\`. Each
+pulled file wraps the body in the server's \`__workflow\` envelope and references its
+per-alias ambient globals at \`.lotics/workflows/<alias>.globals.d.ts\`, so it **is**
+locally typecheckable \u2014 under the dedicated config that mirrors the server's compile
+options:
+
+\`\`\`bash
+tsc -p tsconfig.workflows.json   # same verdict the server gives on \`set\`
+\`\`\`
+
+The main \`npm run typecheck\` excludes \`src/workflows\` (it would apply the app's
+DOM lib, which the server doesn't), so the bodies have their own config. The
+verification that matters still runs on the **server** when you \`set\` \u2014 the same
+guarantee as authoring via \`set_app_workflow\` directly. Edit only the body BETWEEN
+the wrapper lines; the wrapper, the \`/// <reference>\`, and the \`export {};\` marker
+are CLI bookkeeping (stripped on \`set\`). Do not rename a file (the filename is the
+alias the binding is keyed by).
+
+## Authority
+
+\`lotics app deploy\` never authors workflows \u2014 it carries code, queries, and
+capabilities only. \`apps.workflows\` has exactly one author: \`set_app_workflow\`
+(which \`lotics app workflow set\` calls). The typed \`inputs\`/\`outputs\` schema for
+each alias lives in \`package.json#lotics.workflows.<alias>\`.
 `
     },
     {
@@ -30867,6 +31067,18 @@ import http from "node:http";
 import net from "node:net";
 import { spawn } from "node:child_process";
 
+// src/child_env.ts
+function ipv4ChildEnv(env) {
+  return {
+    ...env,
+    NODE_OPTIONS: [
+      env.NODE_OPTIONS,
+      "--dns-result-order=ipv4first",
+      "--network-family-autoselection-attempt-timeout=2000"
+    ].filter(Boolean).join(" ")
+  };
+}
+
 // src/dev/rpc_handler.ts
 var SUPPORTED_OPS = /* @__PURE__ */ new Set([
   "query",
@@ -31327,7 +31539,7 @@ async function startDevServer(args) {
     {
       cwd: args.projectDir,
       stdio: [process.stdin.isTTY ? "inherit" : "ignore", "inherit", "inherit"],
-      env: { ...process.env, FORCE_COLOR: "1" }
+      env: ipv4ChildEnv({ ...process.env, FORCE_COLOR: "1" })
     }
   );
   let stopped = false;
@@ -31751,6 +31963,162 @@ ${lines.join("\n")}
 `;
 }
 
+// ../shared/src/app_query_ast.ts
+function collectQueryTableIds(node) {
+  const result = /* @__PURE__ */ new Set();
+  walk(node, (n) => {
+    if (n.kind === "from_table") result.add(n.table_id);
+  });
+  return result;
+}
+function walk(node, visit) {
+  visit(node);
+  switch (node.kind) {
+    case "from_table":
+      return;
+    case "project":
+    case "filter":
+    case "group":
+    case "window":
+    case "sort":
+    case "limit":
+    case "unpivot":
+      walk(node.from, visit);
+      return;
+    case "join":
+      walk(node.left, visit);
+      walk(node.right, visit);
+      return;
+    case "union":
+      for (const child of node.sources) walk(child, visit);
+      return;
+    default: {
+      const _exhaustive = node;
+      void _exhaustive;
+      return;
+    }
+  }
+}
+
+// src/generate_app_fields.ts
+var HEADER4 = `// Auto-generated by 'lotics app codegen' (and app pull/dev/deploy).
+// DO NOT EDIT \u2014 regenerated from the workspace schema.
+//
+// Runtime field + option ids addressed by stable display-name aliases:
+//   record.data[F.<TABLE>.<field>]            \u2192 "fld_\u2026"
+//   value === OPT.<TABLE>.<field>.<option>    \u2192 "opt_\u2026"
+// A rename on the platform re-runs codegen and moves these in lockstep.
+`;
+function slugifyAlias(name, upper) {
+  const stripped = name.normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/đ/g, "d").replace(/Đ/g, "D");
+  const cased = upper ? stripped.toUpperCase() : stripped.toLowerCase();
+  const slug = cased.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  if (slug === "") return "_";
+  return /^[0-9]/.test(slug) ? `_${slug}` : slug;
+}
+function dedupeAliases(names, upper) {
+  const used = /* @__PURE__ */ new Map();
+  return names.map((name) => {
+    const base = slugifyAlias(name, upper);
+    const seen = used.get(base);
+    if (seen === void 0) {
+      used.set(base, 1);
+      return base;
+    }
+    let n = seen + 1;
+    while (used.has(`${base}_${n}`)) n++;
+    used.set(base, n);
+    used.set(`${base}_${n}`, 1);
+    return `${base}_${n}`;
+  });
+}
+function propKey(alias) {
+  return isValidIdentifier(alias) ? alias : JSON.stringify(alias);
+}
+function aliasTables(tables) {
+  const tableAliases = dedupeAliases(
+    tables.map((t) => t.name),
+    true
+  );
+  return tables.map((table, i2) => {
+    const fieldAliases = dedupeAliases(
+      table.fields.map((f) => f.name),
+      false
+    );
+    return {
+      alias: tableAliases[i2],
+      table,
+      fields: table.fields.map((field, j) => ({ alias: fieldAliases[j], field }))
+    };
+  });
+}
+function emitFieldMap(aliased) {
+  const tableBlocks = aliased.map(({ alias, fields }) => {
+    const fieldLines = fields.map(
+      ({ alias: fieldAlias, field }) => `    ${propKey(fieldAlias)}: ${JSON.stringify(field.id)},`
+    );
+    return `  ${propKey(alias)}: {
+${fieldLines.join("\n")}
+  },`;
+  });
+  return `export const F = {
+${tableBlocks.join("\n")}
+} as const;`;
+}
+function emitOptionMap(aliased) {
+  const tableBlocks = [];
+  for (const { alias, fields } of aliased) {
+    const fieldBlocks = [];
+    for (const { alias: fieldAlias, field } of fields) {
+      const options = field.options ?? [];
+      if (options.length === 0) continue;
+      const optionAliases = dedupeAliases(
+        options.map((o) => o.label),
+        false
+      );
+      const optionLines = options.map(
+        (option, i2) => `      ${propKey(optionAliases[i2])}: ${JSON.stringify(option.id)},`
+      );
+      fieldBlocks.push(`    ${propKey(fieldAlias)}: {
+${optionLines.join("\n")}
+    },`);
+    }
+    if (fieldBlocks.length === 0) continue;
+    tableBlocks.push(`  ${propKey(alias)}: {
+${fieldBlocks.join("\n")}
+  },`);
+  }
+  if (tableBlocks.length === 0) return `export const OPT = {} as const;`;
+  return `export const OPT = {
+${tableBlocks.join("\n")}
+} as const;`;
+}
+function generateAppFields(tables) {
+  if (tables.length === 0) {
+    return `${HEADER4}
+export const F = {} as const;
+
+export const OPT = {} as const;
+
+/** Field-id alias map (empty \u2014 no tables in scope). */
+export type AppFields = typeof F;
+/** Select-option alias map (empty \u2014 no tables in scope). */
+export type AppOptions = typeof OPT;
+`;
+  }
+  const aliased = aliasTables(tables);
+  return `${HEADER4}
+${emitFieldMap(aliased)}
+
+${emitOptionMap(aliased)}
+
+/** Field-id alias map: \`F[<TABLE>][<field>]\` is the \`fld_\u2026\` id (literal-typed). */
+export type AppFields = typeof F;
+/** Select-option alias map: \`OPT[<TABLE>][<field>][<option>]\` is the \`opt_\u2026\` id. */
+export type AppOptions = typeof OPT;
+`;
+}
+
 // src/app_commands.ts
 async function fetchLatestNpmVersion(packageName) {
   try {
@@ -31768,6 +32136,98 @@ async function fetchLatestNpmVersion(packageName) {
     return null;
   }
 }
+var WORKFLOWS_DIR = path4.join("src", "workflows");
+var WORKFLOW_GLOBALS_DIR = path4.join(".lotics", "workflows");
+var FALLBACK_ENVELOPE_PREFIX = "async function __workflow(): Promise<__WorkflowReturn | void> {\n";
+var FALLBACK_ENVELOPE_SUFFIX = "\n}";
+function workflowFileHeader(alias) {
+  const refPath = path4.join("..", "..", WORKFLOW_GLOBALS_DIR, `${alias}.globals.d.ts`).split(path4.sep).join("/");
+  return `/// <reference path="${refPath}" />
+// Auto-pulled workflow body for "${alias}". Edit the BODY between the wrapper
+// lines below, then push with:
+//   lotics app workflow set ${alias}
+// The push goes through set_app_workflow, where the SERVER verifies the body.
+// The __workflow wrapper + the reference above are CLI bookkeeping (stripped on
+// set) \u2014 they only make the body typecheck locally against the workspace types.
+// Do NOT rename this file \u2014 the filename is the alias the binding is keyed by.
+export {};
+`;
+}
+function workflowFilePath(projectDir, alias) {
+  return path4.join(projectDir, WORKFLOWS_DIR, `${alias}.ts`);
+}
+function workflowGlobalsPath(projectDir, alias) {
+  return path4.join(projectDir, WORKFLOW_GLOBALS_DIR, `${alias}.globals.d.ts`);
+}
+function writeWorkflowGlobals(projectDir, alias, dts) {
+  const dir = path4.join(projectDir, WORKFLOW_GLOBALS_DIR);
+  fs3.mkdirSync(dir, { recursive: true });
+  const file = workflowGlobalsPath(projectDir, alias);
+  fs3.writeFileSync(file, `${dts.replace(/\s+$/, "")}
+`);
+  return file;
+}
+function writeWorkflowFile(projectDir, alias, source, envelope = { prefix: FALLBACK_ENVELOPE_PREFIX, suffix: FALLBACK_ENVELOPE_SUFFIX }) {
+  const dir = path4.join(projectDir, WORKFLOWS_DIR);
+  fs3.mkdirSync(dir, { recursive: true });
+  const file = workflowFilePath(projectDir, alias);
+  const body = source.replace(/\s+$/, "");
+  fs3.writeFileSync(file, `${workflowFileHeader(alias)}
+${envelope.prefix}${body}${envelope.suffix}
+`);
+  return file;
+}
+var WORKFLOW_WRAPPER_OPENER = /^\s*async\s+function\s+__workflow\s*\(/;
+function stripWorkflowHeader(content) {
+  const lines = content.split("\n");
+  let headerEnd = 0;
+  while (headerEnd < lines.length && /^\s*\/\//.test(lines[headerEnd])) headerEnd++;
+  while (headerEnd < lines.length && /^\s*export\s*\{\s*\}\s*;?\s*$/.test(lines[headerEnd])) headerEnd++;
+  while (headerEnd < lines.length && lines[headerEnd].trim() === "") headerEnd++;
+  let start;
+  if (headerEnd < lines.length && WORKFLOW_WRAPPER_OPENER.test(lines[headerEnd])) {
+    start = headerEnd;
+  } else if (lines.length > 0 && WORKFLOW_WRAPPER_OPENER.test(lines[0])) {
+    start = 0;
+  } else {
+    return content.replace(/\s+$/, "");
+  }
+  let end = lines.length - 1;
+  while (end > start && lines[end].trim() === "") end--;
+  if (lines[end]?.trim() === "}") {
+    return lines.slice(start + 1, end).join("\n").replace(/\s+$/, "");
+  }
+  return lines.slice(start + 1).join("\n").replace(/\s+$/, "");
+}
+async function writeWorkflowFiles(client, projectDir, app_id, aliases) {
+  const written = [];
+  for (const alias of aliases) {
+    const res = await client.getAppWorkflow(app_id, alias);
+    const source = res.error || res.result === null || typeof res.result !== "object" ? null : res.result.source;
+    if (typeof source !== "string" || source.trim() === "") {
+      console.error(
+        `\u26A0 Skipped src/workflows/${alias}.ts \u2014 the server returned no readable source (${res.error ?? "legacy workflow with no rendered body"}).`
+      );
+      continue;
+    }
+    const envelope = await fetchWorkflowGlobals(client, projectDir, app_id, alias);
+    writeWorkflowFile(projectDir, alias, source, envelope);
+    written.push(alias);
+  }
+  return written;
+}
+async function fetchWorkflowGlobals(client, projectDir, app_id, alias) {
+  try {
+    const { dts, envelope_prefix, envelope_suffix } = await client.getAppWorkflowDts(app_id, alias);
+    writeWorkflowGlobals(projectDir, alias, dts);
+    return { prefix: envelope_prefix, suffix: envelope_suffix };
+  } catch (err2) {
+    console.error(
+      `\u26A0 Could not fetch workflow types for "${alias}" (${err2 instanceof Error ? err2.message : String(err2)}). Wrote the body with the fallback wrapper; its local typecheck may be degraded.`
+    );
+    return { prefix: FALLBACK_ENVELOPE_PREFIX, suffix: FALLBACK_ENVELOPE_SUFFIX };
+  }
+}
 function runTar(args, cwd) {
   return new Promise((resolve, reject2) => {
     const proc = spawn2("tar", args, { cwd, stdio: ["ignore", "ignore", "pipe"] });
@@ -31784,7 +32244,7 @@ function runTar(args, cwd) {
 }
 function runNpm(args, cwd) {
   return new Promise((resolve, reject2) => {
-    const proc = spawn2("npm", args, { cwd, stdio: "inherit" });
+    const proc = spawn2("npm", args, { cwd, stdio: "inherit", env: ipv4ChildEnv(process.env) });
     proc.on("error", reject2);
     proc.on("exit", (code) => {
       if (code === 0) resolve();
@@ -31823,18 +32283,71 @@ function writeAppMeta(projectDir, meta) {
 function writeAppDts(projectDir, manifest) {
   const dotLotics = path4.join(projectDir, ".lotics");
   fs3.mkdirSync(dotLotics, { recursive: true });
-  fs3.writeFileSync(
-    path4.join(dotLotics, "app_workflows.d.ts"),
-    generateAppWorkflowsDts(manifest.workflows)
-  );
-  fs3.writeFileSync(
-    path4.join(dotLotics, "app_queries.d.ts"),
-    generateAppQueriesDts(manifest.queries)
-  );
-  fs3.writeFileSync(
-    path4.join(dotLotics, "app_agents.d.ts"),
-    generateAppAgentsDts(manifest.agents)
-  );
+  const written = [
+    [path4.join(dotLotics, "app_workflows.d.ts"), generateAppWorkflowsDts(manifest.workflows)],
+    [path4.join(dotLotics, "app_queries.d.ts"), generateAppQueriesDts(manifest.queries)],
+    [path4.join(dotLotics, "app_agents.d.ts"), generateAppAgentsDts(manifest.agents)]
+  ];
+  for (const [file, content] of written) fs3.writeFileSync(file, content);
+  return written.map(([file]) => file);
+}
+function readCodegenTablesAllowlist(projectDir) {
+  const pkg2 = JSON.parse(fs3.readFileSync(path4.join(projectDir, "package.json"), "utf-8"));
+  const tables = pkg2.lotics?.codegen?.tables;
+  return Array.isArray(tables) ? tables.filter((t) => typeof t === "string") : [];
+}
+function resolveCodegenTableIds(projectDir, queries) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const decl of Object.values(queries)) {
+    for (const id of collectQueryTableIds(decl.ast)) ids.add(id);
+  }
+  for (const id of readCodegenTablesAllowlist(projectDir)) ids.add(id);
+  return [...ids];
+}
+function writeAppFields(projectDir, tables) {
+  const dotLotics = path4.join(projectDir, ".lotics");
+  fs3.mkdirSync(dotLotics, { recursive: true });
+  const file = path4.join(dotLotics, "app_fields.ts");
+  fs3.writeFileSync(file, generateAppFields(tables));
+  return file;
+}
+async function appCodegen(args) {
+  const projectDir = path4.resolve(args.projectDir ?? process.cwd());
+  const meta = readAppMeta(projectDir);
+  const dtsPaths = writeAppDts(projectDir, {
+    workflows: meta.workflows,
+    queries: meta.queries,
+    agents: meta.agents
+  });
+  for (const p of dtsPaths) console.error(`Regenerated ${p}`);
+  if (!args.client) {
+    console.error(
+      "Skipped .lotics/app_fields.ts \u2014 no workspace credentials resolved. Run authenticated (or set LOTICS_API_KEY) to regenerate field/option ids."
+    );
+    return;
+  }
+  const tableIds = resolveCodegenTableIds(projectDir, meta.queries ?? {});
+  try {
+    const tables = await args.client.getWorkspaceSchema(tableIds);
+    const fieldsPath = writeAppFields(projectDir, tables);
+    console.error(`Regenerated ${fieldsPath} (${tables.length} table${tables.length === 1 ? "" : "s"})`);
+  } catch (err2) {
+    console.error(
+      `\u26A0 Could not fetch the workspace schema (${err2 instanceof Error ? err2.message : String(err2)}). Kept the existing .lotics/app_fields.ts.`
+    );
+  }
+  await refreshWorkflowGlobals(args.client, projectDir, meta.app_id, Object.keys(meta.workflows ?? {}));
+}
+async function refreshWorkflowGlobals(client, projectDir, app_id, aliases) {
+  for (const alias of aliases) {
+    const file = workflowFilePath(projectDir, alias);
+    if (!fs3.existsSync(file)) continue;
+    const body = stripWorkflowHeader(fs3.readFileSync(file, "utf-8"));
+    if (body.trim() === "") continue;
+    const envelope = await fetchWorkflowGlobals(client, projectDir, app_id, alias);
+    writeWorkflowFile(projectDir, alias, body, envelope);
+    console.error(`Refreshed ${path4.relative(projectDir, file)} + its workflow types`);
+  }
 }
 function stampPulledManifest(projectDir, args) {
   writeAppMeta(projectDir, {
@@ -31942,6 +32455,15 @@ async function appPull(client, args) {
     queries: app.queries ?? {},
     agents: app.agents ?? {}
   });
+  const aliases = Object.keys(app.workflows ?? {});
+  if (aliases.length > 0) {
+    const written = await writeWorkflowFiles(client, targetPath, app.id, aliases);
+    if (written.length > 0) {
+      console.error(
+        `Wrote ${written.length} workflow ${written.length === 1 ? "body" : "bodies"} to ${WORKFLOWS_DIR}/ (${written.join(", ")})`
+      );
+    }
+  }
   console.error(`Installing npm dependencies...`);
   await runNpm(["install"], targetPath);
   console.error(`
@@ -31965,14 +32487,14 @@ function readAppSourceText(projectDir) {
   const srcDir = path4.join(projectDir, "src");
   if (!fs3.existsSync(srcDir)) return "";
   const parts = [];
-  const walk = (dir) => {
+  const walk2 = (dir) => {
     for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
       const full = path4.join(dir, entry.name);
-      if (entry.isDirectory()) walk(full);
+      if (entry.isDirectory()) walk2(full);
       else if (/\.(ts|tsx|js|jsx)$/.test(entry.name)) parts.push(fs3.readFileSync(full, "utf8"));
     }
   };
-  walk(srcDir);
+  walk2(srcDir);
   return parts.join("\n");
 }
 async function appDeploy(client, args) {
@@ -32119,6 +32641,209 @@ async function appDev(client, args) {
   console.error("\nStopping\u2026");
   await handle.stop();
 }
+function parseCreatedRecords(value) {
+  if (!Array.isArray(value)) return [];
+  const groups = [];
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object") continue;
+    const tableId = entry.table_id;
+    const recordIds = entry.record_ids;
+    if (typeof tableId !== "string" || !Array.isArray(recordIds)) continue;
+    const ids = recordIds.filter((id) => typeof id === "string");
+    if (ids.length > 0) groups.push({ table_id: tableId, record_ids: ids });
+  }
+  return groups;
+}
+function parseIrreversibleToolNames(value) {
+  if (!Array.isArray(value)) return [];
+  const names = [];
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object") continue;
+    const name = entry.tool_name;
+    if (typeof name === "string" && !names.includes(name)) names.push(name);
+  }
+  return names;
+}
+function printSideEffects(summary) {
+  const created = parseCreatedRecords(summary.created_records);
+  const irreversibleTools = parseIrreversibleToolNames(summary.irreversible_tool_calls);
+  const subWorkflows = summary.sub_workflows_possible === true;
+  console.error("\nCreated records:");
+  if (created.length === 0) {
+    console.error("  (none with ids to clean up)");
+  } else {
+    for (const group of created) {
+      console.error(`  ${group.table_id}: ${group.record_ids.length} record(s)`);
+      const payload = JSON.stringify({ table_id: group.table_id, record_ids: group.record_ids });
+      console.error(`    lotics run delete_records '${payload}'`);
+    }
+  }
+  const irreversiblePart = irreversibleTools.length > 0 ? `Could NOT auto-undo (clean up manually): ${irreversibleTools.join(", ")}.` : "Could NOT auto-undo: none.";
+  const subPart = subWorkflows ? " Sub-workflows may have run (after_* table workflows) \u2014 their effects are NOT in this list." : "";
+  console.error(`
+${irreversiblePart}${subPart}`);
+}
+async function cleanupCreatedRecords(client, created) {
+  if (created.length === 0) {
+    console.error("\nNo created records to clean up.");
+    return true;
+  }
+  console.error("\nCleaning up created records (delete_records \u2014 records only):");
+  let allDeleted = true;
+  for (const group of created) {
+    const res = await client.execute("delete_records", {
+      table_id: group.table_id,
+      record_ids: group.record_ids
+    });
+    if (res.error) {
+      console.error(`  \u2717 ${group.table_id}: ${res.error}`);
+      allDeleted = false;
+    } else {
+      console.error(`  \u2713 ${group.table_id}: deleted ${group.record_ids.length} record(s)`);
+    }
+  }
+  return allDeleted;
+}
+async function appExecuteWorkflow(client, args) {
+  const meta = readAppMeta(process.cwd());
+  const result = await client.appWorkflow(meta.app_id, args.alias, args.inputs);
+  console.log(JSON.stringify(result, null, 2));
+  const status = typeof result.status === "string" ? result.status : "unknown";
+  const message = typeof result.message === "string" ? result.message : "";
+  console.error(`Workflow "${args.alias}" \u2192 ${status}${message ? `: ${message}` : ""}`);
+  let cleanupFailed = false;
+  if ((args.printCreated || args.cleanup) && result.side_effects) {
+    printSideEffects(result.side_effects);
+    if (args.cleanup) {
+      const allDeleted = await cleanupCreatedRecords(
+        client,
+        parseCreatedRecords(result.side_effects.created_records)
+      );
+      cleanupFailed = !allDeleted;
+    }
+  } else if (args.printCreated || args.cleanup) {
+    console.error("\n(no side-effect summary returned by the server)");
+  }
+  if (status === "error" || cleanupFailed) process.exit(1);
+}
+async function appWorkflowSet(client, args) {
+  const projectDir = process.cwd();
+  const meta = readAppMeta(projectDir);
+  const declaration = meta.workflows?.[args.alias];
+  if (!declaration) {
+    console.error(
+      `No workflow "${args.alias}" in package.json#lotics.workflows. Bind it first (set_app_workflow), then 'lotics app pull' to write its body and manifest entry.`
+    );
+    process.exit(1);
+  }
+  const file = workflowFilePath(projectDir, args.alias);
+  if (!fs3.existsSync(file)) {
+    console.error(
+      `No workflow body at ${path4.relative(projectDir, file)}. Run 'lotics app pull ${meta.app_id}' to write src/workflows/${args.alias}.ts, then edit it.`
+    );
+    process.exit(1);
+  }
+  const source = stripWorkflowHeader(fs3.readFileSync(file, "utf-8"));
+  if (source.trim() === "") {
+    console.error(`Workflow body ${path4.relative(projectDir, file)} is empty after stripping the header.`);
+    process.exit(1);
+  }
+  const res = await client.setAppWorkflow(meta.app_id, args.alias, {
+    source,
+    inputs: declaration.inputs,
+    outputs: declaration.outputs
+  });
+  if (res.error) {
+    console.error(`Failed to set workflow "${args.alias}": ${res.error}`);
+    process.exit(1);
+  }
+  const result = res.result ?? {};
+  const workflowId = typeof result.workflow_id === "string" ? result.workflow_id : "(unknown)";
+  console.error(`Set workflow "${args.alias}" \u2192 ${workflowId}`);
+  if (result.outputs && typeof result.outputs === "object") {
+    console.error(`  result.data schema: ${JSON.stringify(result.outputs)}`);
+  }
+}
+async function appWorkflowPull(client) {
+  const projectDir = process.cwd();
+  const meta = readAppMeta(projectDir);
+  const app = await client.getApp(meta.app_id);
+  const aliases = Object.keys(app.workflows ?? {});
+  if (aliases.length === 0) {
+    console.error(`App ${meta.app_id} has no bound workflows.`);
+    return;
+  }
+  const written = await writeWorkflowFiles(client, projectDir, meta.app_id, aliases);
+  console.error(
+    `Wrote ${written.length} workflow ${written.length === 1 ? "body" : "bodies"} to ${WORKFLOWS_DIR}/` + (written.length > 0 ? ` (${written.join(", ")})` : "")
+  );
+}
+function findUiSrcDir(start) {
+  let dir = path4.resolve(start);
+  for (; ; ) {
+    const candidate = path4.join(dir, "packages", "ui", "src");
+    if (fs3.existsSync(candidate) && fs3.statSync(candidate).isDirectory()) return candidate;
+    const parent = path4.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+var UI_ALIAS_FIND_SOURCE = String.raw`/^@lotics\/ui\/(.+)$/`;
+function appUiLink(args) {
+  const projectDir = path4.resolve(args.projectDir ?? process.cwd());
+  const viteConfigPath = path4.join(projectDir, "vite.config.ts");
+  if (!fs3.existsSync(viteConfigPath)) {
+    throw new Error(
+      `No vite.config.ts at ${projectDir}. Run inside a 'lotics app' project directory.`
+    );
+  }
+  const uiSrc = findUiSrcDir(projectDir);
+  if (!uiSrc) {
+    throw new Error(
+      "Cannot find packages/ui/src by walking up from this directory \u2014 `lotics ui link` requires a monorepo checkout. External apps consume @lotics/ui from npm; bump the package version and widen the app's dependency range instead."
+    );
+  }
+  const hasComponent = fs3.existsSync(path4.join(uiSrc, `${args.component}.tsx`)) || fs3.existsSync(path4.join(uiSrc, `${args.component}.ts`)) || fs3.existsSync(path4.join(uiSrc, args.component));
+  if (!hasComponent) {
+    throw new Error(
+      `No '@lotics/ui/${args.component}' under ${uiSrc} (expected ${args.component}.tsx/.ts). Check the component name.`
+    );
+  }
+  const source = fs3.readFileSync(viteConfigPath, "utf-8");
+  const aliasEntry = `{ find: ${UI_ALIAS_FIND_SOURCE}, replacement: ${JSON.stringify(`${uiSrc}/$1`)} },`;
+  const alreadyLinked = source.includes(UI_ALIAS_FIND_SOURCE);
+  if (args.remove) {
+    if (!alreadyLinked) {
+      console.error("No @lotics/ui dev-link alias present \u2014 nothing to remove.");
+      return;
+    }
+    const stripped = source.replace(new RegExp(`^\\s*\\{ find: ${escapeRegExp(UI_ALIAS_FIND_SOURCE)}.*$\\n?`, "m"), "");
+    fs3.writeFileSync(viteConfigPath, stripped);
+    console.error(`Removed the @lotics/ui dev-link alias from ${viteConfigPath}.`);
+    console.error("Restart `lotics app dev` and rm -rf node_modules/.vite to clear cached modules.");
+    return;
+  }
+  if (alreadyLinked) {
+    console.error(`@lotics/ui is already dev-linked in ${viteConfigPath}.`);
+    return;
+  }
+  const aliasMatch = /resolve\s*:\s*\{[\s\S]*?alias\s*:\s*\[/.exec(source);
+  if (!aliasMatch) {
+    throw new Error(
+      `Could not find a resolve.alias array literal in ${viteConfigPath}. Refresh vite.config.ts from the starter (packages/sdk/src/starter_template.ts) and retry.`
+    );
+  }
+  const insertAt = aliasMatch.index + aliasMatch[0].length;
+  const updated = `${source.slice(0, insertAt)}
+      ${aliasEntry}${source.slice(insertAt)}`;
+  fs3.writeFileSync(viteConfigPath, updated);
+  console.error(`Dev-linked @lotics/ui \u2192 ${uiSrc} in ${viteConfigPath}.`);
+  console.error("Restart `lotics app dev` and rm -rf node_modules/.vite to clear cached modules.");
+  console.error("Finalize: PR the packages/ui change \u2192 publish \u2192 `lotics ui link <component> --remove` + bump the app's dep.");
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 
 // src/args.ts
 function parseArgs(argv) {
@@ -32135,6 +32860,8 @@ function parseArgs(argv) {
     message: void 0,
     local: false,
     all: false,
+    printCreated: false,
+    cleanup: false,
     version: false,
     help: false
   };
@@ -32185,6 +32912,13 @@ function parseArgs(argv) {
       case "--all":
         flags.all = true;
         break;
+      case "--print-created":
+      case "--report-effects":
+        flags.printCreated = true;
+        break;
+      case "--cleanup":
+        flags.cleanup = true;
+        break;
       case "--version":
       case "-v":
         flags.version = true;
@@ -32210,6 +32944,34 @@ function parseArgs(argv) {
   return { command, subcommand, toolArgs, restArgs, flags };
 }
 
+// src/inputs.ts
+async function ingestJsonArgs(opts) {
+  let raw = opts.rawArg;
+  if (raw && raw.startsWith("@")) {
+    const argsPath = raw.slice(1);
+    try {
+      raw = opts.readFile(argsPath);
+    } catch (err2) {
+      return {
+        kind: "error",
+        message: `Cannot read args file "${argsPath}": ${err2 instanceof Error ? err2.message : String(err2)}`
+      };
+    }
+  } else if (!raw && !opts.stdinIsTTY) {
+    raw = await opts.readStdin();
+  }
+  if (!raw) return { kind: "ok", args: {} };
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { kind: "error", message: `JSON args must be an object, got: ${raw}` };
+    }
+    return { kind: "ok", args: parsed };
+  } catch {
+    return { kind: "error", message: `Invalid JSON: ${raw}` };
+  }
+}
+
 // src/xlsx.ts
 import fs5 from "node:fs";
 
@@ -38666,8 +39428,8 @@ function parseWorkbook(workbookXml) {
   }
   return { sheets, activeSheetIndex, date1904, namedRanges, printTitlesBySheet, fullCalcOnLoad };
 }
-function parseWorkbookRels(relsXml) {
-  const doc = xmlParser3.parse(relsXml);
+function parseWorkbookRels(relsXml2) {
+  const doc = xmlParser3.parse(relsXml2);
   const rels = doc?.["Relationships"];
   if (!rels) return /* @__PURE__ */ new Map();
   const relArr = rels["Relationship"];
@@ -39703,6 +40465,9 @@ function refToRowCol(ref) {
 function rowColToRef(row, col) {
   return colNumToLetters(col) + String(row);
 }
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
 var PACK_COL_BITS = 14;
 var PACK_COL_MULT = 1 << PACK_COL_BITS;
 function packRowCol(row, col) {
@@ -39874,8 +40639,8 @@ function parseHeaderFooterElement(worksheet) {
   if (hf["@_differentFirst"] === "1") out.differentFirst = true;
   return Object.keys(out).length > 0 ? out : void 0;
 }
-function parseSheetRels(relsXml) {
-  const doc = relsParser.parse(relsXml);
+function parseSheetRels(relsXml2) {
+  const doc = relsParser.parse(relsXml2);
   const relationships = doc?.["Relationships"];
   if (!relationships) return /* @__PURE__ */ new Map();
   const relArr = relationships["Relationship"];
@@ -40179,8 +40944,8 @@ function parseImages(rels, zipEntries) {
   }
   return images;
 }
-function parseDrawingRels(relsXml) {
-  const doc = relsParser.parse(relsXml);
+function parseDrawingRels(relsXml2) {
+  const doc = relsParser.parse(relsXml2);
   const relationships = doc?.["Relationships"];
   if (!relationships) return /* @__PURE__ */ new Map();
   const relArr = relationships["Relationship"];
@@ -41858,1505 +42623,1722 @@ function parsePrintTitlesRef(raw) {
   return result.repeatRows || result.repeatCols ? result : void 0;
 }
 
-// ../xlsx/src/xlsx_writer.ts
-function readWorkbookSheetOrder(originalZip) {
-  const wbBytes = originalZip["xl/workbook.xml"];
-  if (!wbBytes) return [];
-  const xml = decode(wbBytes);
-  const out = [];
-  const re = /<sheet\b[^>]*?r:id="([^"]+)"/g;
-  let m;
-  while ((m = re.exec(xml)) !== null) {
-    out.push(m[1]);
-  }
-  return out;
-}
-function readWorkbookRels(originalZip) {
-  const out = /* @__PURE__ */ new Map();
-  const bytes = originalZip["xl/_rels/workbook.xml.rels"];
-  if (!bytes) return out;
-  const xml = decode(bytes);
-  const re = /<Relationship\b([^/]*?)\/>/g;
-  let m;
-  while ((m = re.exec(xml)) !== null) {
-    const attrs = m[1];
-    const id = /\bId="([^"]+)"/.exec(attrs)?.[1];
-    const type = /\bType="([^"]+)"/.exec(attrs)?.[1] ?? "";
-    const target = /\bTarget="([^"]+)"/.exec(attrs)?.[1] ?? "";
-    if (id) out.set(id, { type, target });
-  }
-  return out;
-}
-function readPivotCacheIdMap(originalZip) {
-  const out = /* @__PURE__ */ new Map();
-  const bytes = originalZip["xl/workbook.xml"];
-  if (!bytes) return out;
-  const xml = decode(bytes);
-  const re = /<pivotCache\b([^/]*?)\/>/g;
-  let m;
-  while ((m = re.exec(xml)) !== null) {
-    const attrs = m[1];
-    const cacheIdMatch = /\bcacheId="(\d+)"/.exec(attrs);
-    const ridMatch = /\br:id="([^"]+)"/.exec(attrs);
-    if (cacheIdMatch && ridMatch) {
-      out.set(parseInt(cacheIdMatch[1], 10), ridMatch[1]);
+// ../xlsx/src/pivot_recompute.ts
+var TOTAL_LABEL = "Grand Total";
+function recomputePivot(table, cache, source) {
+  const records = filterByPageAxis(table, cache, source.records);
+  const rowTuples = distinctTuples(records, table.rowFieldIndices);
+  const colTuples = distinctTuples(records, table.colFieldIndices);
+  const groupKey = (rec) => JSON.stringify([
+    tupleOf(rec, table.rowFieldIndices),
+    tupleOf(rec, table.colFieldIndices)
+  ]);
+  const groups = /* @__PURE__ */ new Map();
+  for (const rec of records) {
+    const key = groupKey(rec);
+    let bucket = groups.get(key);
+    if (!bucket) {
+      bucket = [];
+      groups.set(key, bucket);
     }
+    bucket.push(rec);
   }
-  return out;
+  return buildGrid(table, source, rowTuples, colTuples, groups, records);
 }
-function readSheetPivotPaths(originalZip, sheetTarget) {
-  const sheetPath = `xl/${sheetTarget}`;
-  const relsPath = sheetPath.replace(/([^/]+)$/, "_rels/$1.rels");
-  const bytes = originalZip[relsPath];
-  if (!bytes) return [];
-  const xml = decode(bytes);
-  const re = /<Relationship\b([^/]*?)\/>/g;
-  const out = [];
-  let m;
-  while ((m = re.exec(xml)) !== null) {
-    const attrs = m[1];
-    const type = /\bType="([^"]+)"/.exec(attrs)?.[1] ?? "";
-    if (!type.includes("/pivotTable")) continue;
-    const target = /\bTarget="([^"]+)"/.exec(attrs)?.[1];
-    if (target) out.push(target);
+function filterByPageAxis(table, cache, records) {
+  const filters = [];
+  for (const fi of table.pageFieldIndices) {
+    const cfg = table.fields[fi];
+    if (cfg?.selectedPageItem == null) continue;
+    const cacheField = cache.fields[fi];
+    if (!cacheField) continue;
+    const allowed = cacheField.items[cfg.selectedPageItem];
+    if (allowed) filters.push({ fieldIndex: fi, allowed });
   }
-  return out;
+  if (filters.length === 0) return records;
+  return records.filter(
+    (rec) => filters.every(
+      ({ fieldIndex, allowed }) => cellMatchesItem(rec[fieldIndex], allowed)
+    )
+  );
 }
-function extractPivotRoundTripInfo(originalZip) {
-  const empty = {
-    cachesByWorkbook: /* @__PURE__ */ new Map(),
-    pivotTablesBySheetIndex: /* @__PURE__ */ new Map(),
-    pivotXmlPaths: []
-  };
-  if (!originalZip) return empty;
-  const sheetRIds = readWorkbookSheetOrder(originalZip);
-  const wbRels = readWorkbookRels(originalZip);
-  const cacheRIds = readPivotCacheIdMap(originalZip);
-  const cachesByWorkbook = /* @__PURE__ */ new Map();
-  for (const [cacheId, rid] of cacheRIds) {
-    const rel = wbRels.get(rid);
-    if (!rel) continue;
-    cachesByWorkbook.set(cacheId, rel.target);
-  }
-  const pivotTablesBySheetIndex = /* @__PURE__ */ new Map();
-  for (let i2 = 0; i2 < sheetRIds.length; i2++) {
-    const sheetTarget = wbRels.get(sheetRIds[i2])?.target;
-    if (!sheetTarget) continue;
-    const paths = readSheetPivotPaths(originalZip, sheetTarget);
-    if (paths.length > 0) pivotTablesBySheetIndex.set(i2, paths);
-  }
-  const pivotXmlPaths = [];
-  for (const path7 of Object.keys(originalZip)) {
-    if (path7.startsWith("xl/pivotTables/") && path7.endsWith(".xml")) {
-      pivotXmlPaths.push(path7);
-    }
-    if (path7.startsWith("xl/pivotCache/") && path7.endsWith(".xml")) {
-      pivotXmlPaths.push(path7);
-    }
+function cellMatchesItem(cell, item) {
+  switch (item.kind) {
+    case "string":
+      return typeof cell === "string" && cell === item.value;
+    case "number":
+      return typeof cell === "number" && cell === item.value;
+    case "boolean":
+      return typeof cell === "boolean" && cell === item.value;
+    case "date":
+      return typeof cell === "string" && cell === item.value;
+    case "missing":
+      return cell === void 0 || cell === null || cell === "";
+    case "error":
+      return typeof cell === "string" && cell === item.value;
   }
-  return { cachesByWorkbook, pivotTablesBySheetIndex, pivotXmlPaths };
 }
-function decode(bytes) {
-  return new TextDecoder().decode(bytes);
+function tupleOf(rec, indices) {
+  return indices.map((i2) => rec[i2] ?? null);
 }
-function pivotContentTypeFor(path7) {
-  if (path7.startsWith("xl/pivotTables/") && path7.endsWith(".xml")) {
-    return `<Override PartName="/${path7}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml"/>`;
-  }
-  if (path7.includes("/pivotCacheDefinition") && path7.endsWith(".xml")) {
-    return `<Override PartName="/${path7}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml"/>`;
+function distinctTuples(records, indices) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const rec of records) {
+    const t = tupleOf(rec, indices);
+    const key = JSON.stringify(t);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(t);
   }
-  if (path7.includes("/pivotCacheRecords") && path7.endsWith(".xml")) {
-    return `<Override PartName="/${path7}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml"/>`;
+  out.sort((a, b) => {
+    for (let i2 = 0; i2 < Math.max(a.length, b.length); i2++) {
+      const av = a[i2];
+      const bv = b[i2];
+      if (av === bv) continue;
+      const as = av === null || av === void 0 ? "" : String(av);
+      const bs = bv === null || bv === void 0 ? "" : String(bv);
+      if (as < bs) return -1;
+      if (as > bs) return 1;
+    }
+    return 0;
+  });
+  return out;
+}
+function aggregate(values2, fn) {
+  const numeric = values2.filter((v) => typeof v === "number");
+  switch (fn) {
+    case "count":
+      return values2.filter((v) => v !== null && v !== void 0 && v !== "").length;
+    case "countNums":
+      return numeric.length;
+    case "sum":
+      return numeric.reduce((a, b) => a + b, 0);
+    case "average":
+      if (numeric.length === 0) return null;
+      return numeric.reduce((a, b) => a + b, 0) / numeric.length;
+    case "min":
+      return numeric.length === 0 ? null : Math.min(...numeric);
+    case "max":
+      return numeric.length === 0 ? null : Math.max(...numeric);
+    case "product":
+      return numeric.length === 0 ? null : numeric.reduce((a, b) => a * b, 1);
   }
-  return void 0;
 }
-function exportWorkbook(workbook, originalZip) {
-  const entries = {};
-  const stylesPassthrough = !!originalZip && !workbook.styles.dirty && !!originalZip["xl/styles.xml"];
-  if (originalZip) {
-    const regeneratedPaths = /* @__PURE__ */ new Set();
-    regeneratedPaths.add("xl/sharedStrings.xml");
-    if (!stylesPassthrough) regeneratedPaths.add("xl/styles.xml");
-    regeneratedPaths.add("xl/workbook.xml");
-    regeneratedPaths.add("xl/_rels/workbook.xml.rels");
-    regeneratedPaths.add("[Content_Types].xml");
-    regeneratedPaths.add("_rels/.rels");
-    regeneratedPaths.add("docProps/core.xml");
-    regeneratedPaths.add("docProps/app.xml");
-    for (let i2 = 0; i2 < workbook.sheets.length + 10; i2++) {
-      regeneratedPaths.add(`xl/worksheets/sheet${i2 + 1}.xml`);
-      regeneratedPaths.add(`xl/worksheets/_rels/sheet${i2 + 1}.xml.rels`);
-    }
-    for (const path7 of Object.keys(originalZip)) {
-      if (path7.startsWith("xl/drawings/") || path7.startsWith("xl/charts/") || path7.startsWith("xl/tables/") || path7.startsWith("xl/media/")) {
-        regeneratedPaths.add(path7);
+function buildGrid(table, source, rowTuples, colTuples, groups, allRecords) {
+  const numRowFields = table.rowFieldIndices.length;
+  const numColFields = table.colFieldIndices.length;
+  const numDataFields = Math.max(table.dataFields.length, 1);
+  const showRowGrand = table.display.colGrandTotals;
+  const showColGrand = table.display.rowGrandTotals;
+  const rowLabelCols = Math.max(numRowFields, 1);
+  const colHeaderRows = numColFields + (numDataFields > 0 ? 1 : 0);
+  const headerRows = Math.max(colHeaderRows, 1);
+  const dataCols = colTuples.length * numDataFields;
+  const totalCols = rowLabelCols + dataCols + (showColGrand ? numDataFields : 0);
+  const totalRows = headerRows + rowTuples.length + (showRowGrand ? 1 : 0);
+  const cells = [];
+  for (let r = 0; r < totalRows; r++) {
+    cells.push(new Array(totalCols).fill({ kind: "blank" }));
+  }
+  for (let level = 0; level < numColFields; level++) {
+    let col = rowLabelCols;
+    for (const tuple of colTuples) {
+      const text = formatCellLabel(tuple[level]);
+      for (let i2 = 0; i2 < numDataFields; i2++) {
+        cells[level][col + i2] = { kind: "colHeader", depth: level, text };
       }
+      col += numDataFields;
     }
-    for (const [path7, data] of Object.entries(originalZip)) {
-      if (!regeneratedPaths.has(path7)) entries[path7] = data;
-    }
-  }
-  const sharedStrings = buildSharedStrings(workbook);
-  entries["xl/sharedStrings.xml"] = strToU8(sharedStrings.xml);
-  const stylesResult = stylesPassthrough ? { xml: "", xfMap: /* @__PURE__ */ new Map(), numFmtMap: /* @__PURE__ */ new Map(), dxfMap: /* @__PURE__ */ new Map() } : buildStylesXml(workbook);
-  if (!stylesPassthrough) entries["xl/styles.xml"] = strToU8(stylesResult.xml);
-  const pivotInfo = extractPivotRoundTripInfo(originalZip);
-  entries["xl/workbook.xml"] = strToU8(buildWorkbookXml(workbook, pivotInfo));
-  entries["xl/_rels/workbook.xml.rels"] = strToU8(
-    buildWorkbookRels(workbook, pivotInfo)
-  );
-  const extraContentTypes = [];
-  for (const path7 of pivotInfo.pivotXmlPaths) {
-    const ct = pivotContentTypeFor(path7);
-    if (ct) extraContentTypes.push(ct);
   }
-  let globalChartIndex = 1;
-  let globalImageIndex = 1;
-  let globalTableIndex = 1;
-  for (let i2 = 0; i2 < workbook.sheets.length; i2++) {
-    const sheet = workbook.sheets[i2];
-    const sheetRels = [];
-    let nextRId = 1;
-    const hasCharts = sheet.charts.length > 0;
-    const hasImages = sheet.images.length > 0;
-    const hasDrawings = sheet.drawings.length > 0;
-    const hasTables = sheet.tables.length > 0;
-    const hasHyperlinks = sheet.hyperlinks.size > 0;
-    const needsDrawing = hasCharts || hasImages || hasDrawings;
-    const hyperlinkRIds = /* @__PURE__ */ new Map();
-    if (hasHyperlinks) {
-      for (const [ref, url] of sheet.hyperlinks) {
-        const rId = `rId${nextRId++}`;
-        hyperlinkRIds.set(ref, rId);
-        sheetRels.push(`<Relationship Id="${rId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" Target="${escapeXml(url)}" TargetMode="External"/>`);
+  if (numDataFields > 0) {
+    const labelRow = colHeaderRows - 1;
+    let col = rowLabelCols;
+    for (let _t = 0; _t < colTuples.length; _t++) {
+      for (let d = 0; d < table.dataFields.length; d++) {
+        cells[labelRow][col + d] = {
+          kind: "valueLabel",
+          text: table.dataFields[d].name
+        };
       }
+      col += numDataFields;
     }
-    let drawingRId = "";
-    if (needsDrawing) {
-      drawingRId = `rId${nextRId++}`;
-      sheetRels.push(`<Relationship Id="${drawingRId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing" Target="../drawings/drawing${i2 + 1}.xml"/>`);
-      const drawingRels = [];
-      let drawingRelId = 1;
-      const drawingAnchors = [];
-      for (const chart of sheet.charts) {
-        const chartRId = `rId${drawingRelId++}`;
-        const chartPath = `xl/charts/chart${globalChartIndex}.xml`;
-        entries[chartPath] = strToU8(buildChartXml(chart));
-        extraContentTypes.push(`<Override PartName="/${chartPath}" ContentType="application/vnd.openxmlformats-officedocument.drawingml.chart+xml"/>`);
-        drawingRels.push(`<Relationship Id="${chartRId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart" Target="../charts/chart${globalChartIndex}.xml"/>`);
-        drawingAnchors.push(buildChartAnchorXml(chart, chartRId));
-        globalChartIndex++;
-      }
-      for (const image of sheet.images) {
-        const imgRId = `rId${drawingRelId++}`;
-        const ext = getImageExtension(image.dataUrl);
-        const imgPath = `xl/media/image${globalImageIndex}.${ext}`;
-        const imgBytes = dataUrlToBytes(image.dataUrl);
-        if (imgBytes) {
-          entries[imgPath] = imgBytes;
-          drawingRels.push(`<Relationship Id="${imgRId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="../media/image${globalImageIndex}.${ext}"/>`);
-          drawingAnchors.push(buildImageAnchorXml(image, imgRId));
-          globalImageIndex++;
-        }
-      }
-      for (const drawing of sheet.drawings) {
-        drawingAnchors.push(buildShapeAnchorXml(drawing));
-      }
-      entries[`xl/drawings/drawing${i2 + 1}.xml`] = strToU8(
-        `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<xdr:wsDr xmlns:xdr="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart">
-` + drawingAnchors.join("\n") + `
-</xdr:wsDr>`
-      );
-      extraContentTypes.push(`<Override PartName="/xl/drawings/drawing${i2 + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.drawing+xml"/>`);
-      if (drawingRels.length > 0) {
-        entries[`xl/drawings/_rels/drawing${i2 + 1}.xml.rels`] = strToU8(
-          `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
-${drawingRels.join("\n")}
-</Relationships>`
-        );
+    if (showColGrand) {
+      for (let d = 0; d < table.dataFields.length; d++) {
+        cells[labelRow][rowLabelCols + dataCols + d] = {
+          kind: "valueLabel",
+          text: table.dataFields[d].name
+        };
       }
     }
-    const tableRIds = [];
-    if (hasTables) {
-      for (const table of sheet.tables) {
-        const tableRId = `rId${nextRId++}`;
-        tableRIds.push(tableRId);
-        const tablePath = `xl/tables/table${globalTableIndex}.xml`;
-        entries[tablePath] = strToU8(buildTableXml(table, globalTableIndex));
-        extraContentTypes.push(`<Override PartName="/${tablePath}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml"/>`);
-        sheetRels.push(`<Relationship Id="${tableRId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/table" Target="../tables/table${globalTableIndex}.xml"/>`);
-        globalTableIndex++;
-      }
+  }
+  for (let r = 0; r < rowTuples.length; r++) {
+    const rowTuple = rowTuples[r];
+    const gridRow = headerRows + r;
+    for (let level = 0; level < numRowFields; level++) {
+      cells[gridRow][level] = {
+        kind: "rowHeader",
+        depth: level,
+        text: formatCellLabel(rowTuple[level])
+      };
     }
-    const pivotTargets = pivotInfo.pivotTablesBySheetIndex.get(i2);
-    if (pivotTargets && pivotTargets.length > 0) {
-      for (const target of pivotTargets) {
-        const rId = `rId${nextRId++}`;
-        sheetRels.push(
-          `<Relationship Id="${rId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable" Target="${escapeXml(target)}"/>`
-        );
+    for (let c = 0; c < colTuples.length; c++) {
+      const colTuple = colTuples[c];
+      const groupRecords = groups.get(JSON.stringify([rowTuple, colTuple])) ?? [];
+      for (let d = 0; d < table.dataFields.length; d++) {
+        const df = table.dataFields[d];
+        const values2 = groupRecords.map((rec) => rec[df.fieldIndex]);
+        cells[gridRow][rowLabelCols + c * numDataFields + d] = {
+          kind: "value",
+          value: aggregate(values2, df.subtotal),
+          numFmt: df.numFmt
+        };
       }
     }
-    if (sheetRels.length > 0) {
-      entries[`xl/worksheets/_rels/sheet${i2 + 1}.xml.rels`] = strToU8(
-        `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
-${sheetRels.join("\n")}
-</Relationships>`
+    if (showColGrand) {
+      const rowOnly = allRecords.filter(
+        (rec) => sameTuple(tupleOf(rec, table.rowFieldIndices), rowTuple)
       );
+      for (let d = 0; d < table.dataFields.length; d++) {
+        const df = table.dataFields[d];
+        cells[gridRow][rowLabelCols + dataCols + d] = {
+          kind: "rowTotal",
+          value: aggregate(
+            rowOnly.map((rec) => rec[df.fieldIndex]),
+            df.subtotal
+          )
+        };
+      }
     }
-    entries[`xl/worksheets/sheet${i2 + 1}.xml`] = strToU8(
-      buildSheetXml(sheet, workbook.styles, sharedStrings.index, i2 === workbook.activeSheetIndex, stylesResult.xfMap, stylesResult.numFmtMap, stylesResult.dxfMap, drawingRId, tableRIds, hyperlinkRIds)
-    );
   }
-  entries["docProps/core.xml"] = strToU8(buildCoreProps());
-  entries["docProps/app.xml"] = strToU8(buildAppProps());
-  entries["[Content_Types].xml"] = strToU8(buildContentTypes(workbook.sheets.length, extraContentTypes));
-  entries["_rels/.rels"] = strToU8(buildRootRels());
-  return zipSync(entries, { level: 6 });
-}
-function buildSharedStrings(workbook) {
-  const strings = [];
-  const index = /* @__PURE__ */ new Map();
-  const richTextMap = /* @__PURE__ */ new Map();
-  let totalCount = 0;
-  for (const sheet of workbook.sheets) {
-    for (const cell of sheet.cells.values()) {
-      if (cell.error) continue;
-      if (cell.formula && typeof cell.value === "string") continue;
-      if (typeof cell.value === "string") {
-        totalCount++;
-        if (!index.has(cell.value)) {
-          index.set(cell.value, strings.length);
-          strings.push(cell.value);
-          if (cell.richText && cell.richText.length > 0) {
-            richTextMap.set(cell.value, cell.richText);
-          }
-        }
+  if (showRowGrand) {
+    const gridRow = headerRows + rowTuples.length;
+    cells[gridRow][0] = { kind: "totalLabel", text: TOTAL_LABEL };
+    for (let c = 0; c < colTuples.length; c++) {
+      const colTuple = colTuples[c];
+      const colOnly = allRecords.filter(
+        (rec) => sameTuple(tupleOf(rec, table.colFieldIndices), colTuple)
+      );
+      for (let d = 0; d < table.dataFields.length; d++) {
+        const df = table.dataFields[d];
+        cells[gridRow][rowLabelCols + c * numDataFields + d] = {
+          kind: "colTotal",
+          value: aggregate(
+            colOnly.map((rec) => rec[df.fieldIndex]),
+            df.subtotal
+          )
+        };
       }
     }
-  }
-  const siEntries = strings.map((s) => {
-    const richText = richTextMap.get(s);
-    if (richText) {
-      return `<si>${richText.map((part) => buildRichTextRun(part)).join("")}</si>`;
+    if (showColGrand) {
+      for (let d = 0; d < table.dataFields.length; d++) {
+        const df = table.dataFields[d];
+        cells[gridRow][rowLabelCols + dataCols + d] = {
+          kind: "grandTotal",
+          value: aggregate(
+            allRecords.map((rec) => rec[df.fieldIndex]),
+            df.subtotal
+          )
+        };
+      }
     }
-    const needsPreserve = s.length === 0 || s !== s.trim();
-    const spaceAttr = needsPreserve ? ' xml:space="preserve"' : "";
-    return `<si><t${spaceAttr}>${escapeXml(s)}</t></si>`;
-  });
-  const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="${totalCount}" uniqueCount="${strings.length}">
-${siEntries.join("\n")}
-</sst>`;
-  return { xml, index };
+  }
+  void source;
+  return {
+    cells,
+    headerRows,
+    rowLabelCols,
+    rows: totalRows,
+    cols: totalCols
+  };
 }
-function buildRichTextRun(part) {
-  const needsPreserve = part.text.length === 0 || part.text !== part.text.trim();
-  const spaceAttr = needsPreserve ? ' xml:space="preserve"' : "";
-  if (!part.font) {
-    return `<r><t${spaceAttr}>${escapeXml(part.text)}</t></r>`;
+function sameTuple(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i2 = 0; i2 < a.length; i2++) {
+    if (a[i2] !== b[i2]) {
+      const an = a[i2] === void 0 || a[i2] === null || a[i2] === "";
+      const bn = b[i2] === void 0 || b[i2] === null || b[i2] === "";
+      if (!(an && bn)) return false;
+    }
   }
-  return `<r>${buildRichTextRunProps(part.font)}<t${spaceAttr}>${escapeXml(part.text)}</t></r>`;
+  return true;
 }
-function buildRichTextRunProps(font) {
-  let parts = "";
-  if (font.bold) parts += "<b/>";
-  if (font.italic) parts += "<i/>";
-  if (font.strike) parts += "<strike/>";
-  if (font.underline) parts += `<u val="${font.underline}"/>`;
-  if (font.vertAlign) parts += `<vertAlign val="${font.vertAlign}"/>`;
-  if (font.size) parts += `<sz val="${font.size}"/>`;
-  if (font.color) parts += `<color rgb="${hexToArgb(font.color)}"/>`;
-  if (font.name) parts += `<rFont val="${escapeXml(font.name)}"/>`;
-  return `<rPr>${parts}</rPr>`;
+function formatCellLabel(v) {
+  if (v === void 0 || v === null || v === "") return "(blank)";
+  if (typeof v === "boolean") return v ? "TRUE" : "FALSE";
+  return String(v);
 }
-function buildStylesXml(workbook) {
-  const styles = [];
-  for (let i2 = 0; i2 < workbook.styles.size; i2++) {
-    styles.push(workbook.styles.get(i2));
-  }
-  const numFmtMap = /* @__PURE__ */ new Map();
-  let nextNumFmtId = 164;
-  for (const sheet of workbook.sheets) {
-    for (const cell of sheet.cells.values()) {
-      if (cell.numFmtCode && cell.numFmtCode !== "General" && cell.numFmtCode !== "") {
-        if (!numFmtMap.has(cell.numFmtCode)) {
-          numFmtMap.set(cell.numFmtCode, nextNumFmtId++);
-        }
-      }
-    }
+
+// ../xlsx/src/pivot_model.ts
+var PivotTableModel = class {
+  constructor(config, cache, authored = false) {
+    this.config = config;
+    this.cache = cache;
+    this.authored = authored;
   }
-  const cellNumFmtIds = /* @__PURE__ */ new Map();
-  for (let si = 0; si < workbook.sheets.length; si++) {
-    for (const [ref, cell] of workbook.sheets[si].cells) {
-      if (cell.numFmtCode && cell.numFmtCode !== "General" && cell.numFmtCode !== "") {
-        const id = numFmtMap.get(cell.numFmtCode);
-        if (id !== void 0) cellNumFmtIds.set(`${si}:${ref}`, id);
-      }
+  /**
+   * Recompute the pivot result from the workbook's current source data.
+   * Callers are responsible for triggering recomputation; the model does
+   * not subscribe to workbook changes itself.
+   */
+  recompute(workbook) {
+    const source = readSourceData(workbook, this.cache);
+    if (!source) {
+      this.result = void 0;
+      return;
     }
+    this.result = recomputePivot(this.config, this.cache, source);
   }
-  const fonts = /* @__PURE__ */ new Map();
-  const fontList = [];
-  fonts.set("default", 0);
-  fontList.push({});
-  for (const s of styles) {
-    const key = fontKey(s);
-    if (!fonts.has(key)) {
-      fonts.set(key, fontList.length);
-      fontList.push(s);
-    }
-  }
-  const fillEntries = [];
-  const fillMap = /* @__PURE__ */ new Map();
-  fillEntries.push('<fill><patternFill patternType="none"/></fill>');
-  fillEntries.push('<fill><patternFill patternType="gray125"/></fill>');
-  fillMap.set("", 0);
-  for (const s of styles) {
-    const fk = fillKey(s);
-    if (fk === "" || fillMap.has(fk)) continue;
-    fillMap.set(fk, fillEntries.length);
-    fillEntries.push(buildFillXml(s));
-  }
-  const borderEntries = [];
-  const borderMap = /* @__PURE__ */ new Map();
-  borderEntries.push("<border><left/><right/><top/><bottom/><diagonal/></border>");
-  borderMap.set("", 0);
-  for (const s of styles) {
-    const bk = borderKey(s);
-    if (bk === "" || borderMap.has(bk)) continue;
-    borderMap.set(bk, borderEntries.length);
-    borderEntries.push(buildBorderXml(s));
+};
+function readSourceData(workbook, cache) {
+  if (cache.source.type !== "worksheet") return void 0;
+  const source = cache.source;
+  const sheet = workbook.sheets.find((s) => s.name === source.sheetName);
+  if (!sheet) return void 0;
+  const range = parseRange(source.ref);
+  if (!range) return void 0;
+  const header = [];
+  for (let col = range.startCol; col <= range.endCol; col++) {
+    const cell = sheet.getCell(rowColToRef(range.startRow, col));
+    header.push(formatHeader(cell?.value));
   }
-  const fontsXml = fontList.map((f) => buildFontXml(f)).join("\n");
-  const fillsXml = fillEntries.join("\n");
-  const bordersXml = borderEntries.join("\n");
-  let numFmtsXml = "";
-  if (numFmtMap.size > 0) {
-    const entries = Array.from(numFmtMap.entries()).map(([code, id]) => `<numFmt numFmtId="${id}" formatCode="${escapeXml(code)}"/>`).join("\n");
-    numFmtsXml = `<numFmts count="${numFmtMap.size}">
-${entries}
-</numFmts>
-`;
+  const records = [];
+  for (let row = range.startRow + 1; row <= range.endRow; row++) {
+    const rec = [];
+    for (let col = range.startCol; col <= range.endCol; col++) {
+      const cell = sheet.getCell(rowColToRef(row, col));
+      rec.push(coerceValue(cell?.value));
+    }
+    records.push(rec);
   }
-  const xfEntries = [];
-  const xfMap = /* @__PURE__ */ new Map();
-  for (let styleIdx = 0; styleIdx < styles.length; styleIdx++) {
-    const s = styles[styleIdx];
-    const fontId = fonts.get(fontKey(s)) ?? 0;
-    const fillId = fillMap.get(fillKey(s)) ?? 0;
-    const borderId = borderMap.get(borderKey(s)) ?? 0;
-    const xfKey = `${styleIdx}:0`;
-    xfMap.set(xfKey, xfEntries.length);
-    xfEntries.push(buildXfXml(s, fontId, fillId, borderId, 0));
+  return { header, records };
+}
+function formatHeader(v) {
+  if (v === void 0 || v === null) return "";
+  return String(v);
+}
+function coerceValue(v) {
+  if (v === void 0 || v === null) return void 0;
+  if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+    return v;
   }
-  for (const [cellKey2, numFmtId] of cellNumFmtIds) {
-    const [siStr, ref] = cellKey2.split(":");
-    const cell = workbook.sheets[parseInt(siStr)].cells.get(ref);
-    if (!cell) continue;
-    const xfKey = `${cell.styleIndex}:${numFmtId}`;
-    if (xfMap.has(xfKey)) continue;
-    const s = styles[cell.styleIndex] ?? {};
-    const fontId = fonts.get(fontKey(s)) ?? 0;
-    const fillId = fillMap.get(fillKey(s)) ?? 0;
-    const borderId = borderMap.get(borderKey(s)) ?? 0;
-    xfMap.set(xfKey, xfEntries.length);
-    xfEntries.push(buildXfXml(s, fontId, fillId, borderId, numFmtId));
+  return String(v);
+}
+function parseRange(ref) {
+  const range = ref.includes("!") ? ref.split("!")[1] : ref;
+  const cleaned = range.replace(/\$/g, "");
+  const m = cleaned.match(/^([A-Z]+\d+)(?::([A-Z]+\d+))?$/);
+  if (!m) return void 0;
+  const start = refToRowCol(m[1]);
+  if (!start) return void 0;
+  const endRef = m[2] ?? m[1];
+  const end = refToRowCol(endRef);
+  if (!end) return void 0;
+  return {
+    startRow: start.row,
+    startCol: start.col,
+    endRow: end.row,
+    endCol: end.col
+  };
+}
+
+// ../xlsx/src/pivot_writer.ts
+var MAIN_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+var REL_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+function sourceValueToItem(v) {
+  if (v === void 0 || v === null || v === "") return { kind: "missing" };
+  if (typeof v === "number") return { kind: "number", value: v };
+  if (typeof v === "boolean") return { kind: "boolean", value: v };
+  return { kind: "string", value: v };
+}
+function cacheItemKey(item) {
+  switch (item.kind) {
+    case "missing":
+      return "m:";
+    case "number":
+      return `n:${item.value}`;
+    case "boolean":
+      return `b:${item.value}`;
+    case "string":
+      return `s:${item.value}`;
+    case "date":
+      return `d:${item.value}`;
+    case "error":
+      return `e:${item.value}`;
   }
-  const dxfEntries = [];
-  const dxfMap = /* @__PURE__ */ new Map();
-  for (const sheet of workbook.sheets) {
-    for (const cf of sheet.conditionalFormats) {
-      for (const rule of cf.rules) {
-        if (rule.ruleType === "style" && rule.style) {
-          const key = JSON.stringify(rule.style);
-          if (!dxfMap.has(key)) {
-            dxfMap.set(key, dxfEntries.length);
-            dxfEntries.push(buildDxfXml(rule.style));
-          }
+}
+function enumerateFlags(table, fieldCount) {
+  const axis = /* @__PURE__ */ new Set([...table.rowFieldIndices, ...table.colFieldIndices, ...table.pageFieldIndices]);
+  return Array.from({ length: fieldCount }, (_, i2) => axis.has(i2));
+}
+function buildPivotCacheRecordsXml(records, cache, enumerate) {
+  const indexMaps = cache.fields.map((f, i2) => {
+    if (!enumerate[i2]) return void 0;
+    const m = /* @__PURE__ */ new Map();
+    f.items.forEach((item, idx) => m.set(cacheItemKey(item), idx));
+    return m;
+  });
+  const rows = records.map((rec) => {
+    const cells = cache.fields.map((_f, i2) => {
+      const item = sourceValueToItem(rec[i2]);
+      const map2 = indexMaps[i2];
+      if (map2) {
+        const idx = map2.get(cacheItemKey(item));
+        if (idx === void 0) {
+          throw new Error(
+            `buildPivotCacheRecordsXml: value ${JSON.stringify(rec[i2])} for field "${cache.fields[i2].name}" is missing from its cached shared items`
+          );
         }
+        return `<x v="${idx}"/>`;
       }
-    }
-  }
-  let dxfsXml = '<dxfs count="0"/>';
-  if (dxfEntries.length > 0) {
-    dxfsXml = `<dxfs count="${dxfEntries.length}">
-${dxfEntries.join("\n")}
-</dxfs>`;
+      return inlineRecordCell(item);
+    });
+    return `<r>${cells.join("")}</r>`;
+  });
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<pivotCacheRecords xmlns="${MAIN_NS}" xmlns:r="${REL_NS}" count="${records.length}">` + rows.join("") + `</pivotCacheRecords>`;
+}
+function inlineRecordCell(item) {
+  switch (item.kind) {
+    case "missing":
+      return "<m/>";
+    case "number":
+      return `<n v="${item.value}"/>`;
+    case "boolean":
+      return `<b v="${item.value ? 1 : 0}"/>`;
+    case "date":
+      return `<d v="${escapeXml(item.value)}"/>`;
+    case "error":
+      return `<e v="${escapeXml(item.value)}"/>`;
+    case "string":
+      return `<s v="${escapeXml(item.value)}"/>`;
   }
-  const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
-${numFmtsXml}<fonts count="${fontList.length}">
-${fontsXml}
-</fonts>
-<fills count="${fillEntries.length}">
-${fillsXml}
-</fills>
-<borders count="${borderEntries.length}">
-${bordersXml}
-</borders>
-<cellStyleXfs count="1">
-<xf numFmtId="0" fontId="0" fillId="0" borderId="0"/>
-</cellStyleXfs>
-<cellXfs count="${xfEntries.length}">
-${xfEntries.join("\n")}
-</cellXfs>
-<cellStyles count="1">
-<cellStyle name="Normal" xfId="0" builtinId="0"/>
-</cellStyles>
-${dxfsXml}
-</styleSheet>`;
-  return { xml, xfMap, numFmtMap, dxfMap };
 }
-function buildXfXml(s, fontId, fillId, borderId, numFmtId) {
-  let attrs = `numFmtId="${numFmtId}" fontId="${fontId}" fillId="${fillId}" borderId="${borderId}" xfId="0"`;
-  if (numFmtId > 0) attrs += ' applyNumberFormat="1"';
-  if (fontId > 0) attrs += ' applyFont="1"';
-  if (fillId > 0) attrs += ' applyFill="1"';
-  if (borderId > 0) attrs += ' applyBorder="1"';
-  if (s.horizontalAlign || s.verticalAlign || s.wrapText || s.indent || s.textRotation || s.shrinkToFit) {
-    const hAlign = s.horizontalAlign ? ` horizontal="${s.horizontalAlign}"` : "";
-    const vAlign = s.verticalAlign ? ` vertical="${s.verticalAlign}"` : "";
-    const wrap = s.wrapText ? ' wrapText="1"' : "";
-    const indent = s.indent ? ` indent="${s.indent}"` : "";
-    const rotation = s.textRotation !== void 0 ? ` textRotation="${s.textRotation === "vertical" ? 255 : s.textRotation}"` : "";
-    const shrink = s.shrinkToFit ? ' shrinkToFit="1"' : "";
-    return `<xf ${attrs} applyAlignment="1"><alignment${hAlign}${vAlign}${wrap}${indent}${rotation}${shrink}/></xf>`;
+function buildPivotCacheDefinitionXml(cache, enumerate, recordCount, recordsRelId) {
+  if (cache.source.type !== "worksheet") {
+    throw new Error("buildPivotCacheDefinitionXml: only worksheet sources are supported");
+  }
+  const src = cache.source;
+  const fields = cache.fields.map((f, i2) => cacheFieldXml(f, enumerate[i2])).join("");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<pivotCacheDefinition xmlns="${MAIN_NS}" xmlns:r="${REL_NS}" r:id="${recordsRelId}" refreshOnLoad="1" refreshedBy="Lotics" createdVersion="6" refreshedVersion="6" minRefreshableVersion="3" recordCount="${recordCount}"><cacheSource type="worksheet"><worksheetSource ref="${escapeXml(src.ref)}" sheet="${escapeXml(src.sheetName)}"/></cacheSource><cacheFields count="${cache.fields.length}">${fields}</cacheFields></pivotCacheDefinition>`;
+}
+function cacheFieldXml(field, enumerate) {
+  const name = `name="${escapeXml(field.name)}" numFmtId="0"`;
+  if (!enumerate) {
+    const flags = `containsBlank="${field.items.length === 0 ? 0 : 1}"` + (field.containsNumber ? ` containsString="0" containsNumber="1"` : "");
+    return `<cacheField ${name}><sharedItems ${flags}/></cacheField>`;
+  }
+  const items = field.items.map(sharedItemXml).join("");
+  const hasString = field.items.some((i2) => i2.kind === "string");
+  const hasNumber = field.items.some((i2) => i2.kind === "number");
+  const hasBlank = field.items.some((i2) => i2.kind === "missing");
+  const attrs = `count="${field.items.length}"` + (hasBlank ? ` containsBlank="1"` : "") + (hasNumber && !hasString ? ` containsString="0" containsNumber="1"` : "");
+  return `<cacheField ${name}><sharedItems ${attrs}>${items}</sharedItems></cacheField>`;
+}
+function sharedItemXml(item) {
+  switch (item.kind) {
+    case "missing":
+      return `<m/>`;
+    case "number":
+      return `<n v="${item.value}"/>`;
+    case "boolean":
+      return `<b v="${item.value ? 1 : 0}"/>`;
+    case "date":
+      return `<d v="${escapeXml(item.value)}"/>`;
+    case "error":
+      return `<e v="${escapeXml(item.value)}"/>`;
+    case "string":
+      return `<s v="${escapeXml(item.value)}"/>`;
   }
-  return `<xf ${attrs}/>`;
 }
-function fontKey(s) {
-  return `${s.fontName ?? ""}|${s.fontSize ?? 0}|${s.fontBold ? 1 : 0}|${s.fontItalic ? 1 : 0}|${s.fontColor ?? ""}|${s.fontUnderline ?? ""}|${s.fontStrike ? 1 : 0}`;
+var SUBTOTAL_FN_TO_ENUM = {
+  sum: "sum",
+  count: "count",
+  countNums: "countNums",
+  average: "average",
+  min: "min",
+  max: "max",
+  product: "product"
+};
+function buildPivotTableXml(table, cache) {
+  const rowField = table.rowFieldIndices[0];
+  const colField = table.colFieldIndices[0];
+  if (rowField === void 0 || colField === void 0) {
+    throw new Error("buildPivotTableXml: a row field and a column field are required");
+  }
+  const pageSet = new Set(table.pageFieldIndices);
+  const pivotFields = cache.fields.map((f, i2) => {
+    const onAxis = i2 === rowField ? "axisRow" : i2 === colField ? "axisCol" : pageSet.has(i2) ? "axisPage" : void 0;
+    if (onAxis) return axisPivotFieldXml(onAxis, f.items.length);
+    if (table.dataFields.some((d) => d.fieldIndex === i2)) {
+      return `<pivotField dataField="1" showAll="0"/>`;
+    }
+    return `<pivotField showAll="0"/>`;
+  }).join("");
+  const rowCount = cache.fields[rowField].items.length;
+  const colCount = cache.fields[colField].items.length;
+  const rowItems = axisItemsXml("rowItems", rowCount, table.display.colGrandTotals);
+  const colItems = axisItemsXml("colItems", colCount, table.display.rowGrandTotals);
+  const pageFieldsXml = table.pageFieldIndices.length ? `<pageFields count="${table.pageFieldIndices.length}">` + table.pageFieldIndices.map((fld) => {
+    const sel = table.fields[fld]?.selectedPageItem;
+    const item = sel === null || sel === void 0 ? "" : ` item="${sel}"`;
+    return `<pageField fld="${fld}"${item} hier="-1"/>`;
+  }).join("") + `</pageFields>` : "";
+  const dataFieldsXml = `<dataFields count="${table.dataFields.length}">` + table.dataFields.map((d) => {
+    const fn = SUBTOTAL_FN_TO_ENUM[d.subtotal] ?? "sum";
+    const sub = fn === "sum" ? "" : ` subtotal="${fn}"`;
+    const numFmt = d.numFmt ? ` numFmtId="${escapeXml(d.numFmt)}"` : "";
+    return `<dataField name="${escapeXml(d.name)}" fld="${d.fieldIndex}"${sub} baseField="0" baseItem="0"${numFmt}/>`;
+  }).join("") + `</dataFields>`;
+  const style = `<pivotTableStyleInfo name="${escapeXml(table.styleName ?? "PivotStyleLight16")}" showRowHeaders="1" showColHeaders="1" showRowStripes="${table.display.showRowStripes ? 1 : 0}" showColStripes="${table.display.showColStripes ? 1 : 0}" showLastColumn="1"/>`;
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<pivotTableDefinition xmlns="${MAIN_NS}" xmlns:r="${REL_NS}" name="${escapeXml(table.name)}" cacheId="${table.cacheId}" applyNumberFormats="0" applyBorderFormats="0" applyFontFormats="0" applyPatternFormats="0" applyAlignmentFormats="0" applyWidthHeightFormats="1" dataCaption="Values" updatedVersion="6" minRefreshableVersion="3" useAutoFormatting="1" itemPrintTitles="1" createdVersion="6" indent="0" outline="1" outlineData="1" multipleFieldFilters="0" rowGrandTotals="${table.display.rowGrandTotals ? 1 : 0}" colGrandTotals="${table.display.colGrandTotals ? 1 : 0}"><location ref="${escapeXml(table.ref)}" firstHeaderRow="${table.firstHeaderRow}" firstDataRow="${table.firstDataRow}" firstDataCol="${table.firstDataCol}"/><pivotFields count="${cache.fields.length}">${pivotFields}</pivotFields><rowFields count="1"><field x="${rowField}"/></rowFields>` + rowItems + `<colFields count="1"><field x="${colField}"/></colFields>` + colItems + pageFieldsXml + dataFieldsXml + style + `</pivotTableDefinition>`;
 }
-function buildFontXml(s) {
-  let parts = "";
-  if (s.fontBold) parts += "<b/>";
-  if (s.fontItalic) parts += "<i/>";
-  if (s.fontStrike) parts += "<strike/>";
-  if (s.fontUnderline) parts += `<u val="${s.fontUnderline}"/>`;
-  parts += `<sz val="${s.fontSize ?? 11}"/>`;
-  if (s.fontColor) {
-    parts += `<color rgb="${hexToArgb(s.fontColor)}"/>`;
-  } else {
-    parts += '<color theme="1"/>';
-  }
-  parts += `<name val="${escapeXml(s.fontName ?? "Calibri")}"/>`;
-  return `<font>${parts}</font>`;
+function axisPivotFieldXml(axis, itemCount) {
+  const items = [];
+  for (let i2 = 0; i2 < itemCount; i2++) items.push(`<item x="${i2}"/>`);
+  items.push(`<item t="default"/>`);
+  return `<pivotField axis="${axis}" showAll="0"><items count="${items.length}">${items.join("")}</items></pivotField>`;
 }
-function borderKey(s) {
-  const parts = [];
-  if (s.borderTop) parts.push(`t:${s.borderTop.style}:${s.borderTop.width}:${s.borderTop.color ?? ""}`);
-  if (s.borderRight) parts.push(`r:${s.borderRight.style}:${s.borderRight.width}:${s.borderRight.color ?? ""}`);
-  if (s.borderBottom) parts.push(`b:${s.borderBottom.style}:${s.borderBottom.width}:${s.borderBottom.color ?? ""}`);
-  if (s.borderLeft) parts.push(`l:${s.borderLeft.style}:${s.borderLeft.width}:${s.borderLeft.color ?? ""}`);
-  if (s.borderDiagonal) parts.push(`d:${s.borderDiagonal.style}:${s.borderDiagonal.width}:${s.borderDiagonal.color ?? ""}`);
-  if (s.diagonalUp) parts.push("du");
-  if (s.diagonalDown) parts.push("dd");
-  return parts.join("|");
+function axisItemsXml(element, itemCount, grandTotal) {
+  const items = [];
+  for (let i2 = 0; i2 < itemCount; i2++) items.push(`<i><x v="${i2}"/></i>`);
+  if (grandTotal) items.push(`<i t="grand"><x/></i>`);
+  return `<${element} count="${items.length}">${items.join("")}</${element}>`;
 }
-function toOoxmlBorderStyle(border2) {
-  const ooxmlStyles = [
-    "thin",
-    "medium",
-    "thick",
-    "dotted",
-    "dashed",
-    "double",
-    "hair",
-    "mediumDashed",
-    "dashDot",
-    "mediumDashDot",
-    "dashDotDot",
-    "mediumDashDotDot",
-    "slantDashDot"
-  ];
-  if (ooxmlStyles.includes(border2.style)) return border2.style;
-  if (border2.style === "solid") {
-    if (border2.width <= 1) return "thin";
-    if (border2.width <= 2) return "medium";
-    return "thick";
-  }
-  if (border2.style === "dashed") return "dashed";
-  if (border2.style === "dotted") return "dotted";
-  if (border2.style === "double") return "double";
-  return "thin";
-}
-function buildBorderXml(s) {
-  let attrs = "";
-  if (s.diagonalUp) attrs += ' diagonalUp="1"';
-  if (s.diagonalDown) attrs += ' diagonalDown="1"';
-  const sides = [
-    { tag: "left", border: s.borderLeft },
-    { tag: "right", border: s.borderRight },
-    { tag: "top", border: s.borderTop },
-    { tag: "bottom", border: s.borderBottom },
-    { tag: "diagonal", border: s.borderDiagonal }
-  ];
-  const inner = sides.map(({ tag, border: border2 }) => {
-    if (!border2) return `<${tag}/>`;
-    const ooxmlStyle = toOoxmlBorderStyle(border2);
-    let colorXml = "";
-    if (border2.color) {
-      colorXml = `<color rgb="${hexToArgb(border2.color)}"/>`;
-    }
-    return `<${tag} style="${ooxmlStyle}">${colorXml}</${tag}>`;
-  }).join("");
-  return `<border${attrs}>${inner}</border>`;
+
+// ../xlsx/src/xlsx_writer.ts
+function readWorkbookSheetOrder(originalZip) {
+  const wbBytes = originalZip["xl/workbook.xml"];
+  if (!wbBytes) return [];
+  const xml = decode(wbBytes);
+  const out = [];
+  const re = /<sheet\b[^>]*?r:id="([^"]+)"/g;
+  let m;
+  while ((m = re.exec(xml)) !== null) {
+    out.push(m[1]);
+  }
+  return out;
 }
-function fillKey(s) {
-  if (s.gradientData) return `gradient:${JSON.stringify(s.gradientData)}`;
-  if (s.patternType && s.backgroundPattern) return `pattern:${s.patternType}|${s.backgroundPattern}`;
-  if (s.backgroundColor) return `solid:${s.backgroundColor}`;
-  return "";
+function readWorkbookRels(originalZip) {
+  const out = /* @__PURE__ */ new Map();
+  const bytes = originalZip["xl/_rels/workbook.xml.rels"];
+  if (!bytes) return out;
+  const xml = decode(bytes);
+  const re = /<Relationship\b([^/]*?)\/>/g;
+  let m;
+  while ((m = re.exec(xml)) !== null) {
+    const attrs = m[1];
+    const id = /\bId="([^"]+)"/.exec(attrs)?.[1];
+    const type = /\bType="([^"]+)"/.exec(attrs)?.[1] ?? "";
+    const target = /\bTarget="([^"]+)"/.exec(attrs)?.[1] ?? "";
+    if (id) out.set(id, { type, target });
+  }
+  return out;
 }
-function buildFillXml(s) {
-  if (s.gradientData) {
-    const g = s.gradientData;
-    const stops = g.stops.map((stop) => {
-      const hex = hexToArgb(stop.color);
-      return `<stop position="${stop.position}"><color rgb="${hex}"/></stop>`;
-    }).join("");
-    if (g.type === "radial") {
-      return `<fill><gradientFill type="path" left="0.5" right="0.5" top="0.5" bottom="0.5">${stops}</gradientFill></fill>`;
+function readPivotCacheIdMap(originalZip) {
+  const out = /* @__PURE__ */ new Map();
+  const bytes = originalZip["xl/workbook.xml"];
+  if (!bytes) return out;
+  const xml = decode(bytes);
+  const re = /<pivotCache\b([^/]*?)\/>/g;
+  let m;
+  while ((m = re.exec(xml)) !== null) {
+    const attrs = m[1];
+    const cacheIdMatch = /\bcacheId="(\d+)"/.exec(attrs);
+    const ridMatch = /\br:id="([^"]+)"/.exec(attrs);
+    if (cacheIdMatch && ridMatch) {
+      out.set(parseInt(cacheIdMatch[1], 10), ridMatch[1]);
     }
-    return `<fill><gradientFill degree="${g.degree}">${stops}</gradientFill></fill>`;
   }
-  if (s.patternType && s.backgroundPattern) {
-    const colors = extractFillColors(s.backgroundPattern);
-    let colorAttrs = "";
-    if (colors.fg) colorAttrs += `<fgColor rgb="${hexToArgb(colors.fg)}"/>`;
-    if (colors.bg) colorAttrs += `<bgColor rgb="${hexToArgb(colors.bg)}"/>`;
-    return `<fill><patternFill patternType="${escapeXml(s.patternType)}">${colorAttrs}</patternFill></fill>`;
+  return out;
+}
+function readSheetPivotPaths(originalZip, sheetTarget) {
+  const sheetPath = `xl/${sheetTarget}`;
+  const relsPath = sheetPath.replace(/([^/]+)$/, "_rels/$1.rels");
+  const bytes = originalZip[relsPath];
+  if (!bytes) return [];
+  const xml = decode(bytes);
+  const re = /<Relationship\b([^/]*?)\/>/g;
+  const out = [];
+  let m;
+  while ((m = re.exec(xml)) !== null) {
+    const attrs = m[1];
+    const type = /\bType="([^"]+)"/.exec(attrs)?.[1] ?? "";
+    if (!type.includes("/pivotTable")) continue;
+    const target = /\bTarget="([^"]+)"/.exec(attrs)?.[1];
+    if (target) out.push(target);
   }
-  return `<fill><patternFill patternType="solid"><fgColor rgb="${hexToArgb(s.backgroundColor)}"/></patternFill></fill>`;
+  return out;
 }
-function extractFillColors(css) {
-  const colorMatches = css.match(/rgba?\([^)]+\)/g);
-  if (colorMatches) {
-    return { fg: colorMatches[0], bg: colorMatches[1] };
+function extractPivotRoundTripInfo(originalZip) {
+  const empty = {
+    cachesByWorkbook: /* @__PURE__ */ new Map(),
+    pivotTablesBySheetIndex: /* @__PURE__ */ new Map(),
+    pivotXmlPaths: []
+  };
+  if (!originalZip) return empty;
+  const sheetRIds = readWorkbookSheetOrder(originalZip);
+  const wbRels = readWorkbookRels(originalZip);
+  const cacheRIds = readPivotCacheIdMap(originalZip);
+  const cachesByWorkbook = /* @__PURE__ */ new Map();
+  for (const [cacheId, rid] of cacheRIds) {
+    const rel = wbRels.get(rid);
+    if (!rel) continue;
+    cachesByWorkbook.set(cacheId, rel.target);
   }
-  const hexMatches = css.match(/#[0-9a-fA-F]{6}/g);
-  if (hexMatches) {
-    return { fg: hexMatches[0], bg: hexMatches[1] };
+  const pivotTablesBySheetIndex = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < sheetRIds.length; i2++) {
+    const sheetTarget = wbRels.get(sheetRIds[i2])?.target;
+    if (!sheetTarget) continue;
+    const paths = readSheetPivotPaths(originalZip, sheetTarget);
+    if (paths.length > 0) pivotTablesBySheetIndex.set(i2, paths);
   }
-  return { fg: void 0, bg: void 0 };
-}
-function buildSheetXml(sheet, styles, ssIndex, isActive, xfMap, numFmtMap, dxfMap, drawingRId, tableRIds, hyperlinkRIds) {
-  const rows = [];
-  const rowMap = /* @__PURE__ */ new Map();
-  for (const [ref, cell] of sheet.cells) {
-    const rc = refToRowCol(ref);
-    if (!rc) continue;
-    let arr = rowMap.get(rc.row);
-    if (!arr) {
-      arr = [];
-      rowMap.set(rc.row, arr);
+  const pivotXmlPaths = [];
+  for (const path7 of Object.keys(originalZip)) {
+    if (path7.startsWith("xl/pivotTables/") && path7.endsWith(".xml")) {
+      pivotXmlPaths.push(path7);
+    }
+    if (path7.startsWith("xl/pivotCache/") && path7.endsWith(".xml")) {
+      pivotXmlPaths.push(path7);
     }
-    arr.push({ col: rc.col, cell });
-  }
-  const sortedRows = Array.from(rowMap.keys()).sort((a, b) => a - b);
-  for (const rowNum of sortedRows) {
-    const cells = rowMap.get(rowNum);
-    cells.sort((a, b) => a.col - b.col);
-    const h = sheet.rowHeights.get(rowNum);
-    const rowAttrs = h ? ` ht="${h}" customHeight="1"` : "";
-    const hidden = sheet.hiddenRows.has(rowNum) ? ' hidden="1"' : "";
-    const cellsXml = cells.map(({ col, cell }) => {
-      const ref = rowColToRef(rowNum, col);
-      const type = getCellType(cell, ssIndex);
-      const value = getCellValue(cell, ssIndex);
-      let attrs = `r="${ref}"`;
-      let xfIndex = 0;
-      if (xfMap.size === 0 && cell.originalXfIndex !== void 0) {
-        xfIndex = cell.originalXfIndex;
-      } else {
-        const numFmtId = cell.numFmtCode && cell.numFmtCode !== "General" && cell.numFmtCode !== "" ? numFmtMap.get(cell.numFmtCode) ?? 0 : 0;
-        const xfKey = `${cell.styleIndex}:${numFmtId}`;
-        xfIndex = xfMap.get(xfKey) ?? 0;
-      }
-      if (xfIndex > 0) attrs += ` s="${xfIndex}"`;
-      if (type) attrs += ` t="${type}"`;
-      let inner = "";
-      if (cell.formula) {
-        if (cell.isArrayFormula && cell.arrayRange) {
-          inner += `<f t="array" ref="${cell.arrayRange}">${escapeXml(cell.formula)}</f>`;
-        } else {
-          inner += `<f>${escapeXml(cell.formula)}</f>`;
-        }
-      }
-      if (value !== void 0) inner += `<v>${escapeXml(String(value))}</v>`;
-      return `<c ${attrs}>${inner}</c>`;
-    }).join("");
-    rows.push(`<row r="${rowNum}"${rowAttrs}${hidden}>${cellsXml}</row>`);
   }
-  const cols = [];
-  const allCols = /* @__PURE__ */ new Set([...sheet.colWidths.keys(), ...sheet.hiddenCols]);
-  for (const c of Array.from(allCols).sort((a, b) => a - b)) {
-    const w = sheet.colWidths.get(c) ?? sheet.defaultColWidth;
-    const hidden = sheet.hiddenCols.has(c) ? ' hidden="1"' : "";
-    cols.push(`<col min="${c}" max="${c}" width="${w}" customWidth="1"${hidden}/>`);
+  return { cachesByWorkbook, pivotTablesBySheetIndex, pivotXmlPaths };
+}
+function decode(bytes) {
+  return new TextDecoder().decode(bytes);
+}
+function pivotContentTypeFor(path7) {
+  if (path7.startsWith("xl/pivotTables/") && path7.endsWith(".xml")) {
+    return `<Override PartName="/${path7}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml"/>`;
   }
-  let mergeXml = "";
-  if (sheet.mergedCells.length > 0) {
-    const merges = sheet.mergedCells.map((r) => `<mergeCell ref="${r}"/>`).join("");
-    mergeXml = `<mergeCells count="${sheet.mergedCells.length}">${merges}</mergeCells>`;
+  if (path7.includes("/pivotCacheDefinition") && path7.endsWith(".xml")) {
+    return `<Override PartName="/${path7}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml"/>`;
   }
-  let paneXml = "";
-  let selectionXml = `<selection activeCell="A1" sqref="A1"/>`;
-  if (sheet.freeze) {
-    const activePane = sheet.freeze.col > 0 && sheet.freeze.row > 0 ? "bottomRight" : sheet.freeze.row > 0 ? "bottomLeft" : "topRight";
-    const topLeft = rowColToRef(sheet.freeze.row + 1, sheet.freeze.col + 1);
-    paneXml = `<pane xSplit="${sheet.freeze.col}" ySplit="${sheet.freeze.row}" topLeftCell="${topLeft}" activePane="${activePane}" state="frozen"/>`;
-    selectionXml = `<selection pane="${activePane}" activeCell="${topLeft}" sqref="${topLeft}"/>`;
+  if (path7.includes("/pivotCacheRecords") && path7.endsWith(".xml")) {
+    return `<Override PartName="/${path7}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml"/>`;
   }
-  const tabSelected = isActive ? ' tabSelected="1"' : "";
-  const sheetView = `<sheetView${tabSelected} workbookViewId="0"${!sheet.view.showGridLines ? ' showGridLines="0"' : ""}>${paneXml}${selectionXml}</sheetView>`;
-  let autoFilterXml = "";
-  if (sheet.autoFilter) {
-    let filterCols = "";
-    for (const col of sheet.autoFilter.columns) {
-      if (col.filterValues && col.filterValues.length > 0) {
-        const filters = col.filterValues.map((v) => `<filter val="${escapeXml(v)}"/>`).join("");
-        filterCols += `<filterColumn colId="${col.colIndex}"><filters>${filters}</filters></filterColumn>`;
-      }
+  return void 0;
+}
+var REL_BASE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+function relsXml(rels) {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+` + rels.map((r) => `<Relationship Id="${r.id}" Type="${r.type}" Target="${escapeXml(r.target)}"/>`).join("\n") + `
+</Relationships>`;
+}
+function emitAuthoredPivots(workbook, entries, startFileIndex) {
+  const info = {
+    cachesByWorkbook: /* @__PURE__ */ new Map(),
+    pivotTablesBySheetIndex: /* @__PURE__ */ new Map(),
+    pivotXmlPaths: []
+  };
+  let n = startFileIndex;
+  for (let i2 = 0; i2 < workbook.sheets.length; i2++) {
+    for (const model of workbook.sheets[i2].pivotTables) {
+      if (!model.authored) continue;
+      const idx = n++;
+      const enumerate = enumerateFlags(model.config, model.cache.fields.length);
+      const records = readSourceData(workbook, model.cache)?.records ?? [];
+      const cacheDefPath = `xl/pivotCache/pivotCacheDefinition${idx}.xml`;
+      const recordsPath = `xl/pivotCache/pivotCacheRecords${idx}.xml`;
+      const tablePath = `xl/pivotTables/pivotTable${idx}.xml`;
+      entries[cacheDefPath] = strToU8(buildPivotCacheDefinitionXml(model.cache, enumerate, records.length, "rId1"));
+      entries[`xl/pivotCache/_rels/pivotCacheDefinition${idx}.xml.rels`] = strToU8(
+        relsXml([{ id: "rId1", type: `${REL_BASE}/pivotCacheRecords`, target: `pivotCacheRecords${idx}.xml` }])
+      );
+      entries[recordsPath] = strToU8(buildPivotCacheRecordsXml(records, model.cache, enumerate));
+      entries[tablePath] = strToU8(buildPivotTableXml(model.config, model.cache));
+      entries[`xl/pivotTables/_rels/pivotTable${idx}.xml.rels`] = strToU8(
+        relsXml([{ id: "rId1", type: `${REL_BASE}/pivotCacheDefinition`, target: `../pivotCache/pivotCacheDefinition${idx}.xml` }])
+      );
+      info.cachesByWorkbook.set(model.cache.id, `pivotCache/pivotCacheDefinition${idx}.xml`);
+      const list = info.pivotTablesBySheetIndex.get(i2) ?? [];
+      list.push(`../pivotTables/pivotTable${idx}.xml`);
+      info.pivotTablesBySheetIndex.set(i2, list);
+      info.pivotXmlPaths.push(tablePath, cacheDefPath, recordsPath);
     }
-    autoFilterXml = `<autoFilter ref="${sheet.autoFilter.ref}">${filterCols}</autoFilter>`;
   }
-  let dvXml = "";
-  if (sheet.dataValidations.length > 0) {
-    const dvEntries = sheet.dataValidations.map((dv) => {
-      let attrs = `sqref="${dv.ref}" type="${dv.type}"`;
-      if (dv.operator) attrs += ` operator="${dv.operator}"`;
-      if (!dv.showDropdown) attrs += ' showDropDown="1"';
-      if (dv.errorStyle) attrs += ` errorStyle="${dv.errorStyle}"`;
-      if (dv.errorTitle) attrs += ` errorTitle="${escapeXml(dv.errorTitle)}"`;
-      if (dv.errorMessage) attrs += ` error="${escapeXml(dv.errorMessage)}"`;
-      if (dv.promptTitle) attrs += ` promptTitle="${escapeXml(dv.promptTitle)}"`;
-      if (dv.promptMessage) attrs += ` prompt="${escapeXml(dv.promptMessage)}"`;
-      let inner = "";
-      if (dv.formula1) inner += `<formula1>${escapeXml(dv.formula1)}</formula1>`;
-      if (dv.formula2) inner += `<formula2>${escapeXml(dv.formula2)}</formula2>`;
-      return `<dataValidation ${attrs}>${inner}</dataValidation>`;
-    }).join("");
-    dvXml = `<dataValidations count="${sheet.dataValidations.length}">${dvEntries}</dataValidations>`;
-  }
-  let cfXml = "";
-  if (sheet.conditionalFormats.length > 0) {
-    cfXml = sheet.conditionalFormats.map((cf) => buildConditionalFormattingXml(cf, dxfMap)).join("");
-  }
-  let hyperlinksXml = "";
-  if (hyperlinkRIds && hyperlinkRIds.size > 0) {
-    const hlEntries = Array.from(hyperlinkRIds.entries()).map(([ref, rId]) => `<hyperlink ref="${ref}" r:id="${rId}"/>`).join("");
-    hyperlinksXml = `<hyperlinks>${hlEntries}</hyperlinks>`;
+  return info;
+}
+function mergePivotInfo(a, b) {
+  const cachesByWorkbook = new Map(a.cachesByWorkbook);
+  for (const [k, v] of b.cachesByWorkbook) cachesByWorkbook.set(k, v);
+  const pivotTablesBySheetIndex = /* @__PURE__ */ new Map();
+  for (const [k, v] of a.pivotTablesBySheetIndex) pivotTablesBySheetIndex.set(k, [...v]);
+  for (const [k, v] of b.pivotTablesBySheetIndex) {
+    pivotTablesBySheetIndex.set(k, [...pivotTablesBySheetIndex.get(k) ?? [], ...v]);
   }
-  const drawingXml = drawingRId ? `<drawing r:id="${drawingRId}"/>` : "";
-  let tablePartsXml = "";
-  if (tableRIds && tableRIds.length > 0) {
-    const parts = tableRIds.map((rId) => `<tablePart r:id="${rId}"/>`).join("");
-    tablePartsXml = `<tableParts count="${tableRIds.length}">${parts}</tableParts>`;
+  return { cachesByWorkbook, pivotTablesBySheetIndex, pivotXmlPaths: [...a.pivotXmlPaths, ...b.pivotXmlPaths] };
+}
+function exportWorkbook(workbook, originalZip) {
+  const entries = {};
+  const stylesPassthrough = !!originalZip && !workbook.styles.dirty && !!originalZip["xl/styles.xml"];
+  if (originalZip) {
+    const regeneratedPaths = /* @__PURE__ */ new Set();
+    regeneratedPaths.add("xl/sharedStrings.xml");
+    if (!stylesPassthrough) regeneratedPaths.add("xl/styles.xml");
+    regeneratedPaths.add("xl/workbook.xml");
+    regeneratedPaths.add("xl/_rels/workbook.xml.rels");
+    regeneratedPaths.add("[Content_Types].xml");
+    regeneratedPaths.add("_rels/.rels");
+    regeneratedPaths.add("docProps/core.xml");
+    regeneratedPaths.add("docProps/app.xml");
+    for (let i2 = 0; i2 < workbook.sheets.length + 10; i2++) {
+      regeneratedPaths.add(`xl/worksheets/sheet${i2 + 1}.xml`);
+      regeneratedPaths.add(`xl/worksheets/_rels/sheet${i2 + 1}.xml.rels`);
+    }
+    for (const path7 of Object.keys(originalZip)) {
+      if (path7.startsWith("xl/drawings/") || path7.startsWith("xl/charts/") || path7.startsWith("xl/tables/") || path7.startsWith("xl/media/")) {
+        regeneratedPaths.add(path7);
+      }
+    }
+    for (const [path7, data] of Object.entries(originalZip)) {
+      if (!regeneratedPaths.has(path7)) entries[path7] = data;
+    }
   }
-  const ps = sheet.pageSetup;
-  const hf = sheet.headerFooter;
-  const fitToPage = ps && (ps.fitToWidth !== void 0 || ps.fitToHeight !== void 0);
-  const sheetPrXml = fitToPage ? `<sheetPr><pageSetUpPr fitToPage="1"/></sheetPr>` : "";
-  const marginsXml = (() => {
-    const m = ps?.margins;
-    const left = m?.left ?? 0.7;
-    const right = m?.right ?? 0.7;
-    const top = m?.top ?? 0.75;
-    const bottom = m?.bottom ?? 0.75;
-    const header = m?.header ?? 0.3;
-    const footer = m?.footer ?? 0.3;
-    return `<pageMargins left="${left}" right="${right}" top="${top}" bottom="${bottom}" header="${header}" footer="${footer}"/>`;
-  })();
-  let pageSetupXml = "";
-  if (ps) {
-    const attrs = [];
-    if (ps.paperSize !== void 0) attrs.push(`paperSize="${ps.paperSize}"`);
-    if (ps.scale !== void 0) attrs.push(`scale="${ps.scale}"`);
-    if (ps.fitToWidth !== void 0) attrs.push(`fitToWidth="${ps.fitToWidth}"`);
-    if (ps.fitToHeight !== void 0) attrs.push(`fitToHeight="${ps.fitToHeight}"`);
-    if (ps.orientation) attrs.push(`orientation="${ps.orientation}"`);
-    if (attrs.length > 0) pageSetupXml = `<pageSetup ${attrs.join(" ")}/>`;
+  const sharedStrings = buildSharedStrings(workbook);
+  entries["xl/sharedStrings.xml"] = strToU8(sharedStrings.xml);
+  const stylesResult = stylesPassthrough ? { xml: "", xfMap: /* @__PURE__ */ new Map(), numFmtMap: /* @__PURE__ */ new Map(), dxfMap: /* @__PURE__ */ new Map() } : buildStylesXml(workbook);
+  if (!stylesPassthrough) entries["xl/styles.xml"] = strToU8(stylesResult.xml);
+  const roundTripInfo = extractPivotRoundTripInfo(originalZip);
+  const authoredStartIndex = roundTripInfo.pivotXmlPaths.filter((p) => p.startsWith("xl/pivotTables/")).length + 1;
+  const pivotInfo = mergePivotInfo(roundTripInfo, emitAuthoredPivots(workbook, entries, authoredStartIndex));
+  entries["xl/workbook.xml"] = strToU8(buildWorkbookXml(workbook, pivotInfo));
+  entries["xl/_rels/workbook.xml.rels"] = strToU8(
+    buildWorkbookRels(workbook, pivotInfo)
+  );
+  const extraContentTypes = [];
+  for (const path7 of pivotInfo.pivotXmlPaths) {
+    const ct = pivotContentTypeFor(path7);
+    if (ct) extraContentTypes.push(ct);
   }
-  let headerFooterXml = "";
-  if (hf) {
-    const rootAttrs = [];
-    if (hf.differentOddEven) rootAttrs.push(`differentOddEven="1"`);
-    if (hf.differentFirst) rootAttrs.push(`differentFirst="1"`);
-    const inner = [];
-    if (hf.oddHeader) inner.push(`<oddHeader>${escapeXml(hf.oddHeader)}</oddHeader>`);
-    if (hf.oddFooter) inner.push(`<oddFooter>${escapeXml(hf.oddFooter)}</oddFooter>`);
-    if (hf.evenHeader) inner.push(`<evenHeader>${escapeXml(hf.evenHeader)}</evenHeader>`);
-    if (hf.evenFooter) inner.push(`<evenFooter>${escapeXml(hf.evenFooter)}</evenFooter>`);
-    if (hf.firstHeader) inner.push(`<firstHeader>${escapeXml(hf.firstHeader)}</firstHeader>`);
-    if (hf.firstFooter) inner.push(`<firstFooter>${escapeXml(hf.firstFooter)}</firstFooter>`);
-    if (inner.length > 0) {
-      const attrStr = rootAttrs.length > 0 ? ` ${rootAttrs.join(" ")}` : "";
-      headerFooterXml = `<headerFooter${attrStr}>${inner.join("")}</headerFooter>`;
+  let globalChartIndex = 1;
+  let globalImageIndex = 1;
+  let globalTableIndex = 1;
+  for (let i2 = 0; i2 < workbook.sheets.length; i2++) {
+    const sheet = workbook.sheets[i2];
+    const sheetRels = [];
+    let nextRId = 1;
+    const hasCharts = sheet.charts.length > 0;
+    const hasImages = sheet.images.length > 0;
+    const hasDrawings = sheet.drawings.length > 0;
+    const hasTables = sheet.tables.length > 0;
+    const hasHyperlinks = sheet.hyperlinks.size > 0;
+    const needsDrawing = hasCharts || hasImages || hasDrawings;
+    const hyperlinkRIds = /* @__PURE__ */ new Map();
+    if (hasHyperlinks) {
+      for (const [ref, url] of sheet.hyperlinks) {
+        const rId = `rId${nextRId++}`;
+        hyperlinkRIds.set(ref, rId);
+        sheetRels.push(`<Relationship Id="${rId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" Target="${escapeXml(url)}" TargetMode="External"/>`);
+      }
     }
-  }
-  let dimensionRef = "A1";
-  if (sortedRows.length > 0) {
-    let minCol = Infinity, maxCol = 0;
-    const minRow = sortedRows[0];
-    const maxRow = sortedRows[sortedRows.length - 1];
-    for (const rowNum of sortedRows) {
-      const cells = rowMap.get(rowNum);
-      for (const { col } of cells) {
-        if (col < minCol) minCol = col;
-        if (col > maxCol) maxCol = col;
+    let drawingRId = "";
+    if (needsDrawing) {
+      drawingRId = `rId${nextRId++}`;
+      sheetRels.push(`<Relationship Id="${drawingRId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing" Target="../drawings/drawing${i2 + 1}.xml"/>`);
+      const drawingRels = [];
+      let drawingRelId = 1;
+      const drawingAnchors = [];
+      for (const chart of sheet.charts) {
+        const chartRId = `rId${drawingRelId++}`;
+        const chartPath = `xl/charts/chart${globalChartIndex}.xml`;
+        entries[chartPath] = strToU8(buildChartXml(chart));
+        extraContentTypes.push(`<Override PartName="/${chartPath}" ContentType="application/vnd.openxmlformats-officedocument.drawingml.chart+xml"/>`);
+        drawingRels.push(`<Relationship Id="${chartRId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart" Target="../charts/chart${globalChartIndex}.xml"/>`);
+        drawingAnchors.push(buildChartAnchorXml(chart, chartRId));
+        globalChartIndex++;
+      }
+      for (const image of sheet.images) {
+        const imgRId = `rId${drawingRelId++}`;
+        const ext = getImageExtension(image.dataUrl);
+        const imgPath = `xl/media/image${globalImageIndex}.${ext}`;
+        const imgBytes = dataUrlToBytes(image.dataUrl);
+        if (imgBytes) {
+          entries[imgPath] = imgBytes;
+          drawingRels.push(`<Relationship Id="${imgRId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="../media/image${globalImageIndex}.${ext}"/>`);
+          drawingAnchors.push(buildImageAnchorXml(image, imgRId));
+          globalImageIndex++;
+        }
+      }
+      for (const drawing of sheet.drawings) {
+        drawingAnchors.push(buildShapeAnchorXml(drawing));
+      }
+      entries[`xl/drawings/drawing${i2 + 1}.xml`] = strToU8(
+        `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<xdr:wsDr xmlns:xdr="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart">
+` + drawingAnchors.join("\n") + `
+</xdr:wsDr>`
+      );
+      extraContentTypes.push(`<Override PartName="/xl/drawings/drawing${i2 + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.drawing+xml"/>`);
+      if (drawingRels.length > 0) {
+        entries[`xl/drawings/_rels/drawing${i2 + 1}.xml.rels`] = strToU8(
+          `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+${drawingRels.join("\n")}
+</Relationships>`
+        );
       }
     }
-    dimensionRef = `${rowColToRef(minRow, minCol)}:${rowColToRef(maxRow, maxCol)}`;
+    const tableRIds = [];
+    if (hasTables) {
+      for (const table of sheet.tables) {
+        const tableRId = `rId${nextRId++}`;
+        tableRIds.push(tableRId);
+        const tablePath = `xl/tables/table${globalTableIndex}.xml`;
+        entries[tablePath] = strToU8(buildTableXml(table, globalTableIndex));
+        extraContentTypes.push(`<Override PartName="/${tablePath}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml"/>`);
+        sheetRels.push(`<Relationship Id="${tableRId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/table" Target="../tables/table${globalTableIndex}.xml"/>`);
+        globalTableIndex++;
+      }
+    }
+    const pivotTargets = pivotInfo.pivotTablesBySheetIndex.get(i2);
+    if (pivotTargets && pivotTargets.length > 0) {
+      for (const target of pivotTargets) {
+        const rId = `rId${nextRId++}`;
+        sheetRels.push(
+          `<Relationship Id="${rId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable" Target="${escapeXml(target)}"/>`
+        );
+      }
+    }
+    if (sheetRels.length > 0) {
+      entries[`xl/worksheets/_rels/sheet${i2 + 1}.xml.rels`] = strToU8(
+        `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+${sheetRels.join("\n")}
+</Relationships>`
+      );
+    }
+    entries[`xl/worksheets/sheet${i2 + 1}.xml`] = strToU8(
+      buildSheetXml(sheet, workbook.styles, sharedStrings.index, i2 === workbook.activeSheetIndex, stylesResult.xfMap, stylesResult.numFmtMap, stylesResult.dxfMap, drawingRId, tableRIds, hyperlinkRIds)
+    );
   }
-  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
-  xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
-${sheetPrXml}<dimension ref="${dimensionRef}"/>
-<sheetViews>${sheetView}</sheetViews>
-<sheetFormatPr defaultRowHeight="${sheet.defaultRowHeight}" defaultColWidth="${sheet.defaultColWidth}"/>
-${cols.length > 0 ? `<cols>${cols.join("")}</cols>` : ""}
-<sheetData>
-${rows.join("\n")}
-</sheetData>
-${autoFilterXml}${mergeXml}${cfXml}${dvXml}${hyperlinksXml}${marginsXml}${pageSetupXml}${headerFooterXml}${drawingXml}${tablePartsXml}
-</worksheet>`;
-}
-function getCellType(cell, ssIndex) {
-  if (cell.error) return "e";
-  if (cell.formula && typeof cell.value === "string") return "str";
-  if (typeof cell.value === "string" && ssIndex.has(cell.value)) return "s";
-  if (typeof cell.value === "boolean") return "b";
-  return void 0;
+  entries["docProps/core.xml"] = strToU8(buildCoreProps());
+  entries["docProps/app.xml"] = strToU8(buildAppProps());
+  entries["[Content_Types].xml"] = strToU8(buildContentTypes(workbook.sheets.length, extraContentTypes));
+  entries["_rels/.rels"] = strToU8(buildRootRels());
+  return zipSync(entries, { level: 6 });
 }
-function getCellValue(cell, ssIndex) {
-  if (cell.value === null) return void 0;
-  if (cell.error) return cell.error;
-  if (cell.formula && typeof cell.value === "string") return cell.value;
-  if (typeof cell.value === "string") {
-    const idx = ssIndex.get(cell.value);
-    return idx !== void 0 ? idx : cell.value;
+function buildSharedStrings(workbook) {
+  const strings = [];
+  const index = /* @__PURE__ */ new Map();
+  const richTextMap = /* @__PURE__ */ new Map();
+  let totalCount = 0;
+  for (const sheet of workbook.sheets) {
+    for (const cell of sheet.cells.values()) {
+      if (cell.error) continue;
+      if (cell.formula && typeof cell.value === "string") continue;
+      if (typeof cell.value === "string") {
+        totalCount++;
+        if (!index.has(cell.value)) {
+          index.set(cell.value, strings.length);
+          strings.push(cell.value);
+          if (cell.richText && cell.richText.length > 0) {
+            richTextMap.set(cell.value, cell.richText);
+          }
+        }
+      }
+    }
   }
-  if (typeof cell.value === "boolean") return cell.value ? 1 : 0;
-  return cell.value;
-}
-function quoteSheetName(name) {
-  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? name : `'${name.replace(/'/g, "''")}'`;
-}
-function buildWorkbookXml(workbook, pivotInfo) {
-  const sheets = workbook.sheets.map(
-    (s, i2) => `<sheet name="${escapeXml(s.name)}" sheetId="${i2 + 1}" r:id="rId${i2 + 1}"/>`
-  ).join("\n");
-  const nameEntries = [];
-  for (const [name, value] of workbook.namedRanges) {
-    nameEntries.push(`<definedName name="${escapeXml(name)}">${escapeXml(value)}</definedName>`);
-  }
-  workbook.sheets.forEach((s, i2) => {
-    const pt = s.printTitles;
-    if (!pt || !pt.repeatRows && !pt.repeatCols) return;
-    const parts = [];
-    const sheetName = quoteSheetName(s.name);
-    if (pt.repeatCols) {
-      const [start, end] = pt.repeatCols;
-      parts.push(`${sheetName}!$${colNumToLetters(start)}:$${colNumToLetters(end)}`);
-    }
-    if (pt.repeatRows) {
-      const [start, end] = pt.repeatRows;
-      parts.push(`${sheetName}!$${start}:$${end}`);
+  const siEntries = strings.map((s) => {
+    const richText = richTextMap.get(s);
+    if (richText) {
+      return `<si>${richText.map((part) => buildRichTextRun(part)).join("")}</si>`;
     }
-    nameEntries.push(
-      `<definedName name="_xlnm.Print_Titles" localSheetId="${i2}">${escapeXml(parts.join(","))}</definedName>`
-    );
+    const needsPreserve = s.length === 0 || s !== s.trim();
+    const spaceAttr = needsPreserve ? ' xml:space="preserve"' : "";
+    return `<si><t${spaceAttr}>${escapeXml(s)}</t></si>`;
   });
-  const definedNames = nameEntries.length > 0 ? `
-<definedNames>
-${nameEntries.join("\n")}
-</definedNames>` : "";
-  let pivotCachesBlock = "";
-  if (pivotInfo && pivotInfo.cachesByWorkbook.size > 0) {
-    const baseRId = workbook.sheets.length + 3;
-    const cacheIds = [...pivotInfo.cachesByWorkbook.keys()].sort((a, b) => a - b);
-    const items = cacheIds.map((cacheId, i2) => `<pivotCache cacheId="${cacheId}" r:id="rId${baseRId + i2}"/>`).join("\n");
-    pivotCachesBlock = `
-<pivotCaches>
-${items}
-</pivotCaches>`;
-  }
-  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
-  xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
-<bookViews>
-<workbookView activeTab="${workbook.activeSheetIndex}"/>
-</bookViews>
-<sheets>
-${sheets}
-</sheets>${definedNames}${pivotCachesBlock}
-<calcPr fullCalcOnLoad="1"/>
-</workbook>`;
+  const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="${totalCount}" uniqueCount="${strings.length}">
+${siEntries.join("\n")}
+</sst>`;
+  return { xml, index };
 }
-function buildWorkbookRels(workbook, pivotInfo) {
-  const rels = workbook.sheets.map(
-    (_, i2) => `<Relationship Id="rId${i2 + 1}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet${i2 + 1}.xml"/>`
-  );
-  rels.push(`<Relationship Id="rId${workbook.sheets.length + 1}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>`);
-  rels.push(`<Relationship Id="rId${workbook.sheets.length + 2}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" Target="sharedStrings.xml"/>`);
-  if (pivotInfo && pivotInfo.cachesByWorkbook.size > 0) {
-    const baseRId = workbook.sheets.length + 3;
-    const cacheIds = [...pivotInfo.cachesByWorkbook.keys()].sort((a, b) => a - b);
-    cacheIds.forEach((cacheId, i2) => {
-      const target = pivotInfo.cachesByWorkbook.get(cacheId);
-      if (!target) return;
-      rels.push(
-        `<Relationship Id="rId${baseRId + i2}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition" Target="${escapeXml(target)}"/>`
-      );
-    });
+function buildRichTextRun(part) {
+  const needsPreserve = part.text.length === 0 || part.text !== part.text.trim();
+  const spaceAttr = needsPreserve ? ' xml:space="preserve"' : "";
+  if (!part.font) {
+    return `<r><t${spaceAttr}>${escapeXml(part.text)}</t></r>`;
   }
-  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
-${rels.join("\n")}
-</Relationships>`;
-}
-function buildContentTypes(sheetCount, extraTypes = []) {
-  const sheetTypes = Array.from(
-    { length: sheetCount },
-    (_, i2) => `<Override PartName="/xl/worksheets/sheet${i2 + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`
-  ).join("\n");
-  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
-<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
-<Default Extension="xml" ContentType="application/xml"/>
-<Default Extension="png" ContentType="image/png"/>
-<Default Extension="jpeg" ContentType="image/jpeg"/>
-<Default Extension="jpg" ContentType="image/jpeg"/>
-<Default Extension="gif" ContentType="image/gif"/>
-<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>
-${sheetTypes}
-<Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>
-<Override PartName="/xl/sharedStrings.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml"/>
-<Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/>
-<Override PartName="/docProps/app.xml" ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml"/>
-${extraTypes.join("\n")}
-</Types>`;
-}
-function buildRootRels() {
-  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
-<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>
-<Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/>
-<Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties" Target="docProps/app.xml"/>
-</Relationships>`;
-}
-function buildCoreProps() {
-  const now = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
-  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties"
-  xmlns:dc="http://purl.org/dc/elements/1.1/"
-  xmlns:dcterms="http://purl.org/dc/terms/"
-  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-<dcterms:created xsi:type="dcterms:W3CDTF">${now}</dcterms:created>
-<dcterms:modified xsi:type="dcterms:W3CDTF">${now}</dcterms:modified>
-</cp:coreProperties>`;
-}
-function buildAppProps() {
-  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties">
-<Application>Microsoft Excel</Application>
-</Properties>`;
+  return `<r>${buildRichTextRunProps(part.font)}<t${spaceAttr}>${escapeXml(part.text)}</t></r>`;
 }
-var CHART_TYPE_MAP2 = {
-  bar: "c:barChart",
-  col: "c:barChart",
-  line: "c:lineChart",
-  pie: "c:pieChart",
-  doughnut: "c:doughnutChart",
-  area: "c:areaChart",
-  scatter: "c:scatterChart",
-  bubble: "c:bubbleChart",
-  radar: "c:radarChart",
-  stock: "c:stockChart",
-  surface: "c:surfaceChart"
-};
-function buildSeriesXml(s, idx, chartType, categories) {
-  let nameXml = "";
-  if (s.name) nameXml = `<c:tx><c:strRef><c:strCache><c:ptCount val="1"/><c:pt idx="0"><c:v>${escapeXml(s.name)}</c:v></c:pt></c:strCache></c:strRef></c:tx>`;
-  let colorXml = "";
-  if (s.color) colorXml = `<c:spPr><a:solidFill><a:srgbClr val="${hexToOoxmlRgb(s.color)}"/></a:solidFill></c:spPr>`;
-  const valTag = chartType === "scatter" || chartType === "bubble" ? "c:yVal" : "c:val";
-  const valPts = s.values.map((v, i2) => `<c:pt idx="${i2}"><c:v>${v}</c:v></c:pt>`).join("");
-  const valXml = `<${valTag}><c:numRef><c:numCache><c:ptCount val="${s.values.length}"/>${valPts}</c:numCache></c:numRef></${valTag}>`;
-  let catXml = "";
-  if (categories && categories.length > 0) {
-    const catTag = chartType === "scatter" || chartType === "bubble" ? "c:xVal" : "c:cat";
-    const catPts = categories.map((c, i2) => `<c:pt idx="${i2}"><c:v>${escapeXml(c)}</c:v></c:pt>`).join("");
-    catXml = `<${catTag}><c:strRef><c:strCache><c:ptCount val="${categories.length}"/>${catPts}</c:strCache></c:strRef></${catTag}>`;
-  }
-  let bubbleXml = "";
-  if (s.bubbleSizes) {
-    const bPts = s.bubbleSizes.map((v, i2) => `<c:pt idx="${i2}"><c:v>${v}</c:v></c:pt>`).join("");
-    bubbleXml = `<c:bubbleSize><c:numRef><c:numCache><c:ptCount val="${s.bubbleSizes.length}"/>${bPts}</c:numCache></c:numRef></c:bubbleSize>`;
-  }
-  return `<c:ser><c:idx val="${idx}"/><c:order val="${idx}"/>${nameXml}${colorXml}${catXml}${valXml}${bubbleXml}</c:ser>`;
+function buildRichTextRunProps(font) {
+  let parts = "";
+  if (font.bold) parts += "<b/>";
+  if (font.italic) parts += "<i/>";
+  if (font.strike) parts += "<strike/>";
+  if (font.underline) parts += `<u val="${font.underline}"/>`;
+  if (font.vertAlign) parts += `<vertAlign val="${font.vertAlign}"/>`;
+  if (font.size) parts += `<sz val="${font.size}"/>`;
+  if (font.color) parts += `<color rgb="${hexToArgb(font.color)}"/>`;
+  if (font.name) parts += `<rFont val="${escapeXml(font.name)}"/>`;
+  return `<rPr>${parts}</rPr>`;
 }
-function buildChartTypeElement(chartType, seriesXml, needsAxIds) {
-  const chartTag = CHART_TYPE_MAP2[chartType] ?? "c:barChart";
-  const isBar = chartType === "bar";
-  let barDir = "";
-  if (chartTag === "c:barChart") {
-    barDir = isBar ? '<c:barDir val="bar"/>' : '<c:barDir val="col"/>';
+function buildStylesXml(workbook) {
+  const styles = [];
+  for (let i2 = 0; i2 < workbook.styles.size; i2++) {
+    styles.push(workbook.styles.get(i2));
   }
-  let grouping = "";
-  if (chartTag === "c:barChart") {
-    grouping = '<c:grouping val="clustered"/>';
-  } else if (chartTag === "c:lineChart" || chartTag === "c:areaChart") {
-    grouping = '<c:grouping val="clustered"/>';
+  const numFmtMap = /* @__PURE__ */ new Map();
+  let nextNumFmtId = 164;
+  for (const sheet of workbook.sheets) {
+    for (const cell of sheet.cells.values()) {
+      if (cell.numFmtCode && cell.numFmtCode !== "General" && cell.numFmtCode !== "") {
+        if (!numFmtMap.has(cell.numFmtCode)) {
+          numFmtMap.set(cell.numFmtCode, nextNumFmtId++);
+        }
+      }
+    }
   }
-  const axIds = needsAxIds ? '<c:axId val="1"/><c:axId val="2"/>' : "";
-  return `<${chartTag}>${barDir}${grouping}${seriesXml}${axIds}</${chartTag}>`;
-}
-function buildChartXml(chart) {
-  const needsAxIds = chart.chartType !== "pie" && chart.chartType !== "doughnut";
-  let plotArea;
-  if (chart.chartType === "combo") {
-    const groups = /* @__PURE__ */ new Map();
-    chart.series.forEach((s, idx) => {
-      const sType = s.seriesChartType ?? "col";
-      let group = groups.get(sType);
-      if (!group) {
-        group = [];
-        groups.set(sType, group);
+  const cellNumFmtIds = /* @__PURE__ */ new Map();
+  for (let si = 0; si < workbook.sheets.length; si++) {
+    for (const [ref, cell] of workbook.sheets[si].cells) {
+      if (cell.numFmtCode && cell.numFmtCode !== "General" && cell.numFmtCode !== "") {
+        const id = numFmtMap.get(cell.numFmtCode);
+        if (id !== void 0) cellNumFmtIds.set(`${si}:${ref}`, id);
       }
-      group.push({ series: s, idx });
-    });
-    let chartElements = "";
-    for (const [groupType, groupSeries] of groups) {
-      const groupSeriesXml = groupSeries.map(
-        ({ series, idx }) => buildSeriesXml(series, idx, groupType, chart.categories)
-      ).join("");
-      chartElements += buildChartTypeElement(groupType, groupSeriesXml, true);
     }
-    plotArea = `<c:plotArea><c:layout/>${chartElements}`;
-  } else {
-    const seriesXml = chart.series.map(
-      (s, idx) => buildSeriesXml(s, idx, chart.chartType, chart.categories)
-    ).join("");
-    plotArea = `<c:plotArea><c:layout/>${buildChartTypeElement(chart.chartType, seriesXml, needsAxIds)}`;
   }
-  if (chart.chartType !== "pie" && chart.chartType !== "doughnut") {
-    const axes = chart.axes ?? [{ type: "category" }, { type: "value" }];
-    for (let i2 = 0; i2 < axes.length; i2++) {
-      const ax = axes[i2];
-      const axId = i2 + 1;
-      const crossId = i2 === 0 ? 2 : 1;
-      let axTag;
-      switch (ax.type) {
-        case "value":
-          axTag = "c:valAx";
-          break;
-        case "date":
-          axTag = "c:dateAx";
-          break;
-        case "series":
-          axTag = "c:serAx";
-          break;
-        default:
-          axTag = "c:catAx";
-          break;
+  const fonts = /* @__PURE__ */ new Map();
+  const fontList = [];
+  fonts.set("default", 0);
+  fontList.push({});
+  for (const s of styles) {
+    const key = fontKey(s);
+    if (!fonts.has(key)) {
+      fonts.set(key, fontList.length);
+      fontList.push(s);
+    }
+  }
+  const fillEntries = [];
+  const fillMap = /* @__PURE__ */ new Map();
+  fillEntries.push('<fill><patternFill patternType="none"/></fill>');
+  fillEntries.push('<fill><patternFill patternType="gray125"/></fill>');
+  fillMap.set("", 0);
+  for (const s of styles) {
+    const fk = fillKey(s);
+    if (fk === "" || fillMap.has(fk)) continue;
+    fillMap.set(fk, fillEntries.length);
+    fillEntries.push(buildFillXml(s));
+  }
+  const borderEntries = [];
+  const borderMap = /* @__PURE__ */ new Map();
+  borderEntries.push("<border><left/><right/><top/><bottom/><diagonal/></border>");
+  borderMap.set("", 0);
+  for (const s of styles) {
+    const bk = borderKey(s);
+    if (bk === "" || borderMap.has(bk)) continue;
+    borderMap.set(bk, borderEntries.length);
+    borderEntries.push(buildBorderXml(s));
+  }
+  const fontsXml = fontList.map((f) => buildFontXml(f)).join("\n");
+  const fillsXml = fillEntries.join("\n");
+  const bordersXml = borderEntries.join("\n");
+  let numFmtsXml = "";
+  if (numFmtMap.size > 0) {
+    const entries = Array.from(numFmtMap.entries()).map(([code, id]) => `<numFmt numFmtId="${id}" formatCode="${escapeXml(code)}"/>`).join("\n");
+    numFmtsXml = `<numFmts count="${numFmtMap.size}">
+${entries}
+</numFmts>
+`;
+  }
+  const xfEntries = [];
+  const xfMap = /* @__PURE__ */ new Map();
+  for (let styleIdx = 0; styleIdx < styles.length; styleIdx++) {
+    const s = styles[styleIdx];
+    const fontId = fonts.get(fontKey(s)) ?? 0;
+    const fillId = fillMap.get(fillKey(s)) ?? 0;
+    const borderId = borderMap.get(borderKey(s)) ?? 0;
+    const xfKey = `${styleIdx}:0`;
+    xfMap.set(xfKey, xfEntries.length);
+    xfEntries.push(buildXfXml(s, fontId, fillId, borderId, 0));
+  }
+  for (const [cellKey2, numFmtId] of cellNumFmtIds) {
+    const [siStr, ref] = cellKey2.split(":");
+    const cell = workbook.sheets[parseInt(siStr)].cells.get(ref);
+    if (!cell) continue;
+    const xfKey = `${cell.styleIndex}:${numFmtId}`;
+    if (xfMap.has(xfKey)) continue;
+    const s = styles[cell.styleIndex] ?? {};
+    const fontId = fonts.get(fontKey(s)) ?? 0;
+    const fillId = fillMap.get(fillKey(s)) ?? 0;
+    const borderId = borderMap.get(borderKey(s)) ?? 0;
+    xfMap.set(xfKey, xfEntries.length);
+    xfEntries.push(buildXfXml(s, fontId, fillId, borderId, numFmtId));
+  }
+  const dxfEntries = [];
+  const dxfMap = /* @__PURE__ */ new Map();
+  for (const sheet of workbook.sheets) {
+    for (const cf of sheet.conditionalFormats) {
+      for (const rule of cf.rules) {
+        if (rule.ruleType === "style" && rule.style) {
+          const key = JSON.stringify(rule.style);
+          if (!dxfMap.has(key)) {
+            dxfMap.set(key, dxfEntries.length);
+            dxfEntries.push(buildDxfXml(rule.style));
+          }
+        }
       }
-      let titleXml2 = "";
-      if (ax.title) titleXml2 = `<c:title><c:tx><c:rich><a:bodyPr/><a:lstStyle/><a:p><a:r><a:t>${escapeXml(ax.title)}</a:t></a:r></a:p></c:rich></c:tx></c:title>`;
-      let scalingXml = '<c:scaling><c:orientation val="minMax"/>';
-      if (ax.min !== void 0) scalingXml += `<c:min val="${ax.min}"/>`;
-      if (ax.max !== void 0) scalingXml += `<c:max val="${ax.max}"/>`;
-      scalingXml += "</c:scaling>";
-      const numFmt = ax.numFmt ? `<c:numFmt formatCode="${escapeXml(ax.numFmt)}" sourceLinked="0"/>` : "";
-      plotArea += `<${axTag}><c:axId val="${axId}"/>${scalingXml}${titleXml2}${numFmt}<c:crossAx val="${crossId}"/></${axTag}>`;
     }
   }
-  plotArea += "</c:plotArea>";
-  let titleXml = "";
-  if (chart.title) {
-    titleXml = `<c:title><c:tx><c:rich><a:bodyPr/><a:lstStyle/><a:p><a:r><a:t>${escapeXml(chart.title)}</a:t></a:r></a:p></c:rich></c:tx></c:title>`;
+  let dxfsXml = '<dxfs count="0"/>';
+  if (dxfEntries.length > 0) {
+    dxfsXml = `<dxfs count="${dxfEntries.length}">
+${dxfEntries.join("\n")}
+</dxfs>`;
   }
-  let legendXml = "";
-  if (chart.legendPosition && chart.legendPosition !== "none") {
-    const posMap = { top: "t", bottom: "b", left: "l", right: "r" };
-    legendXml = `<c:legend><c:legendPos val="${posMap[chart.legendPosition] ?? "b"}"/></c:legend>`;
+  const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+${numFmtsXml}<fonts count="${fontList.length}">
+${fontsXml}
+</fonts>
+<fills count="${fillEntries.length}">
+${fillsXml}
+</fills>
+<borders count="${borderEntries.length}">
+${bordersXml}
+</borders>
+<cellStyleXfs count="1">
+<xf numFmtId="0" fontId="0" fillId="0" borderId="0"/>
+</cellStyleXfs>
+<cellXfs count="${xfEntries.length}">
+${xfEntries.join("\n")}
+</cellXfs>
+<cellStyles count="1">
+<cellStyle name="Normal" xfId="0" builtinId="0"/>
+</cellStyles>
+${dxfsXml}
+</styleSheet>`;
+  return { xml, xfMap, numFmtMap, dxfMap };
+}
+function buildXfXml(s, fontId, fillId, borderId, numFmtId) {
+  let attrs = `numFmtId="${numFmtId}" fontId="${fontId}" fillId="${fillId}" borderId="${borderId}" xfId="0"`;
+  if (numFmtId > 0) attrs += ' applyNumberFormat="1"';
+  if (fontId > 0) attrs += ' applyFont="1"';
+  if (fillId > 0) attrs += ' applyFill="1"';
+  if (borderId > 0) attrs += ' applyBorder="1"';
+  if (s.horizontalAlign || s.verticalAlign || s.wrapText || s.indent || s.textRotation || s.shrinkToFit) {
+    const hAlign = s.horizontalAlign ? ` horizontal="${s.horizontalAlign}"` : "";
+    const vAlign = s.verticalAlign ? ` vertical="${s.verticalAlign}"` : "";
+    const wrap = s.wrapText ? ' wrapText="1"' : "";
+    const indent = s.indent ? ` indent="${s.indent}"` : "";
+    const rotation = s.textRotation !== void 0 ? ` textRotation="${s.textRotation === "vertical" ? 255 : s.textRotation}"` : "";
+    const shrink = s.shrinkToFit ? ' shrinkToFit="1"' : "";
+    return `<xf ${attrs} applyAlignment="1"><alignment${hAlign}${vAlign}${wrap}${indent}${rotation}${shrink}/></xf>`;
   }
-  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<c:chartSpace xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
-<c:chart>${titleXml}${plotArea}${legendXml}</c:chart>
-</c:chartSpace>`;
+  return `<xf ${attrs}/>`;
 }
-function buildAnchorPosition(pos) {
-  return `<xdr:col>${pos.col}</xdr:col><xdr:colOff>${pos.colOffset ?? 0}</xdr:colOff><xdr:row>${pos.row}</xdr:row><xdr:rowOff>${pos.rowOffset ?? 0}</xdr:rowOff>`;
+function fontKey(s) {
+  return `${s.fontName ?? ""}|${s.fontSize ?? 0}|${s.fontBold ? 1 : 0}|${s.fontItalic ? 1 : 0}|${s.fontColor ?? ""}|${s.fontUnderline ?? ""}|${s.fontStrike ? 1 : 0}`;
 }
-function buildChartAnchorXml(chart, rId) {
-  return `<xdr:twoCellAnchor>
-<xdr:from>${buildAnchorPosition(chart.anchor.from)}</xdr:from>
-<xdr:to>${buildAnchorPosition(chart.anchor.to)}</xdr:to>
-<xdr:graphicFrame macro="">
-<xdr:nvGraphicFramePr><xdr:cNvPr id="0" name="Chart"/><xdr:cNvGraphicFramePr/></xdr:nvGraphicFramePr>
-<xdr:xfrm><a:off x="0" y="0"/><a:ext cx="0" cy="0"/></xdr:xfrm>
-<a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/chart"><c:chart xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" r:id="${rId}"/></a:graphicData></a:graphic>
-</xdr:graphicFrame>
-<xdr:clientData/>
-</xdr:twoCellAnchor>`;
+function buildFontXml(s) {
+  let parts = "";
+  if (s.fontBold) parts += "<b/>";
+  if (s.fontItalic) parts += "<i/>";
+  if (s.fontStrike) parts += "<strike/>";
+  if (s.fontUnderline) parts += `<u val="${s.fontUnderline}"/>`;
+  parts += `<sz val="${s.fontSize ?? 11}"/>`;
+  if (s.fontColor) {
+    parts += `<color rgb="${hexToArgb(s.fontColor)}"/>`;
+  } else {
+    parts += '<color theme="1"/>';
+  }
+  parts += `<name val="${escapeXml(s.fontName ?? "Calibri")}"/>`;
+  return `<font>${parts}</font>`;
 }
-function buildImageAnchorXml(image, rId) {
-  return `<xdr:twoCellAnchor editAs="oneCell">
-<xdr:from>${buildAnchorPosition(image.tl)}</xdr:from>
-<xdr:to>${buildAnchorPosition(image.br)}</xdr:to>
-<xdr:pic>
-<xdr:nvPicPr><xdr:cNvPr id="0" name="Image"/><xdr:cNvPicPr/></xdr:nvPicPr>
-<xdr:blipFill><a:blip xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" r:embed="${rId}"/><a:stretch><a:fillRect/></a:stretch></xdr:blipFill>
-<xdr:spPr><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></xdr:spPr>
-</xdr:pic>
-<xdr:clientData/>
-</xdr:twoCellAnchor>`;
+function borderKey(s) {
+  const parts = [];
+  if (s.borderTop) parts.push(`t:${s.borderTop.style}:${s.borderTop.width}:${s.borderTop.color ?? ""}`);
+  if (s.borderRight) parts.push(`r:${s.borderRight.style}:${s.borderRight.width}:${s.borderRight.color ?? ""}`);
+  if (s.borderBottom) parts.push(`b:${s.borderBottom.style}:${s.borderBottom.width}:${s.borderBottom.color ?? ""}`);
+  if (s.borderLeft) parts.push(`l:${s.borderLeft.style}:${s.borderLeft.width}:${s.borderLeft.color ?? ""}`);
+  if (s.borderDiagonal) parts.push(`d:${s.borderDiagonal.style}:${s.borderDiagonal.width}:${s.borderDiagonal.color ?? ""}`);
+  if (s.diagonalUp) parts.push("du");
+  if (s.diagonalDown) parts.push("dd");
+  return parts.join("|");
 }
-function buildShapeAnchorXml(drawing) {
-  let fillXml = "";
-  if (drawing.fillColor) fillXml = `<a:solidFill><a:srgbClr val="${hexToOoxmlRgb(drawing.fillColor)}"/></a:solidFill>`;
-  let outlineXml = "";
-  if (drawing.outlineColor) {
-    const w = Math.round((drawing.outlineWidth ?? 1) * 12700);
-    outlineXml = `<a:ln w="${w}"><a:solidFill><a:srgbClr val="${hexToOoxmlRgb(drawing.outlineColor)}"/></a:solidFill></a:ln>`;
+function toOoxmlBorderStyle(border2) {
+  const ooxmlStyles = [
+    "thin",
+    "medium",
+    "thick",
+    "dotted",
+    "dashed",
+    "double",
+    "hair",
+    "mediumDashed",
+    "dashDot",
+    "mediumDashDot",
+    "dashDotDot",
+    "mediumDashDotDot",
+    "slantDashDot"
+  ];
+  if (ooxmlStyles.includes(border2.style)) return border2.style;
+  if (border2.style === "solid") {
+    if (border2.width <= 1) return "thin";
+    if (border2.width <= 2) return "medium";
+    return "thick";
   }
-  const geom = drawing.geometry ?? "rect";
-  let textXml = "";
-  if (drawing.text) textXml = `<xdr:txBody><a:bodyPr/><a:lstStyle/><a:p><a:r><a:t>${escapeXml(drawing.text)}</a:t></a:r></a:p></xdr:txBody>`;
-  return `<xdr:twoCellAnchor>
-<xdr:from>${buildAnchorPosition(drawing.anchor.from)}</xdr:from>
-<xdr:to>${buildAnchorPosition(drawing.anchor.to)}</xdr:to>
-<xdr:sp><xdr:nvSpPr><xdr:cNvPr id="0" name="Shape"/><xdr:cNvSpPr/></xdr:nvSpPr>
-<xdr:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="0" cy="0"/></a:xfrm><a:prstGeom prst="${geom}"><a:avLst/></a:prstGeom>${fillXml}${outlineXml}</xdr:spPr>
-${textXml}</xdr:sp>
-<xdr:clientData/>
-</xdr:twoCellAnchor>`;
+  if (border2.style === "dashed") return "dashed";
+  if (border2.style === "dotted") return "dotted";
+  if (border2.style === "double") return "double";
+  return "thin";
 }
-function buildTableXml(table, tableId) {
-  const colsXml = table.columns.map((col) => {
-    let inner = "";
-    if (col.totalsFunction) inner += `<totalsRowFunction>${escapeXml(col.totalsFunction)}</totalsRowFunction>`;
-    if (col.totalsFormula) inner += `<totalsRowFormula>${escapeXml(col.totalsFormula)}</totalsRowFormula>`;
-    return `<tableColumn id="${col.id}" name="${escapeXml(col.name)}">${inner}</tableColumn>`;
+function buildBorderXml(s) {
+  let attrs = "";
+  if (s.diagonalUp) attrs += ' diagonalUp="1"';
+  if (s.diagonalDown) attrs += ' diagonalDown="1"';
+  const sides = [
+    { tag: "left", border: s.borderLeft },
+    { tag: "right", border: s.borderRight },
+    { tag: "top", border: s.borderTop },
+    { tag: "bottom", border: s.borderBottom },
+    { tag: "diagonal", border: s.borderDiagonal }
+  ];
+  const inner = sides.map(({ tag, border: border2 }) => {
+    if (!border2) return `<${tag}/>`;
+    const ooxmlStyle = toOoxmlBorderStyle(border2);
+    let colorXml = "";
+    if (border2.color) {
+      colorXml = `<color rgb="${hexToArgb(border2.color)}"/>`;
+    }
+    return `<${tag} style="${ooxmlStyle}">${colorXml}</${tag}>`;
   }).join("");
-  const autoFilterXml = table.autoFilter ? `<autoFilter ref="${escapeXml(table.ref)}"/>` : "";
-  const styleName = table.styleName ?? "TableStyleMedium2";
-  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<table xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" id="${tableId}" name="${escapeXml(table.name)}" displayName="${escapeXml(table.displayName)}" ref="${escapeXml(table.ref)}" totalsRowCount="${table.totalsRow ? 1 : 0}">
-${autoFilterXml}
-<tableColumns count="${table.columns.length}">${colsXml}</tableColumns>
-<tableStyleInfo name="${escapeXml(styleName)}" showFirstColumn="0" showLastColumn="0" showRowStripes="1" showColumnStripes="0"/>
-</table>`;
+  return `<border${attrs}>${inner}</border>`;
 }
-function buildConditionalFormattingXml(cf, dxfMap) {
-  const rules = cf.rules.map((rule) => {
-    switch (rule.ruleType) {
-      case "colorScale": {
-        const count = rule.colors.length;
-        const cfvos = count === 2 ? '<cfvo type="min"/><cfvo type="max"/>' : '<cfvo type="min"/><cfvo type="percentile" val="50"/><cfvo type="max"/>';
-        const colors = rule.colors.map((c) => `<color rgb="${hexToArgb(c)}"/>`).join("");
-        return `<cfRule type="colorScale" priority="${rule.priority}"><colorScale>${cfvos}${colors}</colorScale></cfRule>`;
-      }
-      case "dataBar": {
-        const showVal = rule.showValue ? "1" : "0";
-        return `<cfRule type="dataBar" priority="${rule.priority}"><dataBar minLength="${rule.minLength}" maxLength="${rule.maxLength}" showValue="${showVal}"><cfvo type="min"/><cfvo type="max"/><color rgb="${hexToArgb(rule.color)}"/></dataBar></cfRule>`;
-      }
-      case "iconSet": {
-        const thresholds = rule.thresholds.map((t) => {
-          if (t.type === "min" || t.type === "autoMin") return '<cfvo type="min"/>';
-          if (t.type === "max" || t.type === "autoMax") return '<cfvo type="max"/>';
-          return `<cfvo type="${t.type}" val="${t.value ?? 0}"/>`;
-        }).join("");
-        const showVal = rule.showValue ? "" : ' showValue="0"';
-        const reverse = rule.reverse ? ' reverse="1"' : "";
-        return `<cfRule type="iconSet" priority="${rule.priority}"><iconSet iconSet="${rule.iconSet}"${showVal}${reverse}>${thresholds}</iconSet></cfRule>`;
+function fillKey(s) {
+  if (s.gradientData) return `gradient:${JSON.stringify(s.gradientData)}`;
+  if (s.patternType && s.backgroundPattern) return `pattern:${s.patternType}|${s.backgroundPattern}`;
+  if (s.backgroundColor) return `solid:${s.backgroundColor}`;
+  return "";
+}
+function buildFillXml(s) {
+  if (s.gradientData) {
+    const g = s.gradientData;
+    const stops = g.stops.map((stop) => {
+      const hex = hexToArgb(stop.color);
+      return `<stop position="${stop.position}"><color rgb="${hex}"/></stop>`;
+    }).join("");
+    if (g.type === "radial") {
+      return `<fill><gradientFill type="path" left="0.5" right="0.5" top="0.5" bottom="0.5">${stops}</gradientFill></fill>`;
+    }
+    return `<fill><gradientFill degree="${g.degree}">${stops}</gradientFill></fill>`;
+  }
+  if (s.patternType && s.backgroundPattern) {
+    const colors = extractFillColors(s.backgroundPattern);
+    let colorAttrs = "";
+    if (colors.fg) colorAttrs += `<fgColor rgb="${hexToArgb(colors.fg)}"/>`;
+    if (colors.bg) colorAttrs += `<bgColor rgb="${hexToArgb(colors.bg)}"/>`;
+    return `<fill><patternFill patternType="${escapeXml(s.patternType)}">${colorAttrs}</patternFill></fill>`;
+  }
+  return `<fill><patternFill patternType="solid"><fgColor rgb="${hexToArgb(s.backgroundColor)}"/></patternFill></fill>`;
+}
+function extractFillColors(css) {
+  const colorMatches = css.match(/rgba?\([^)]+\)/g);
+  if (colorMatches) {
+    return { fg: colorMatches[0], bg: colorMatches[1] };
+  }
+  const hexMatches = css.match(/#[0-9a-fA-F]{6}/g);
+  if (hexMatches) {
+    return { fg: hexMatches[0], bg: hexMatches[1] };
+  }
+  return { fg: void 0, bg: void 0 };
+}
+function buildSheetXml(sheet, styles, ssIndex, isActive, xfMap, numFmtMap, dxfMap, drawingRId, tableRIds, hyperlinkRIds) {
+  const rows = [];
+  const rowMap = /* @__PURE__ */ new Map();
+  for (const [ref, cell] of sheet.cells) {
+    const rc = refToRowCol(ref);
+    if (!rc) continue;
+    let arr = rowMap.get(rc.row);
+    if (!arr) {
+      arr = [];
+      rowMap.set(rc.row, arr);
+    }
+    arr.push({ col: rc.col, cell });
+  }
+  const sortedRows = Array.from(rowMap.keys()).sort((a, b) => a - b);
+  for (const rowNum of sortedRows) {
+    const cells = rowMap.get(rowNum);
+    cells.sort((a, b) => a.col - b.col);
+    const h = sheet.rowHeights.get(rowNum);
+    const rowAttrs = h ? ` ht="${h}" customHeight="1"` : "";
+    const hidden = sheet.hiddenRows.has(rowNum) ? ' hidden="1"' : "";
+    const cellsXml = cells.map(({ col, cell }) => {
+      const ref = rowColToRef(rowNum, col);
+      const type = getCellType(cell, ssIndex);
+      const value = getCellValue(cell, ssIndex);
+      let attrs = `r="${ref}"`;
+      let xfIndex = 0;
+      if (xfMap.size === 0 && cell.originalXfIndex !== void 0) {
+        xfIndex = cell.originalXfIndex;
+      } else {
+        const numFmtId = cell.numFmtCode && cell.numFmtCode !== "General" && cell.numFmtCode !== "" ? numFmtMap.get(cell.numFmtCode) ?? 0 : 0;
+        const xfKey = `${cell.styleIndex}:${numFmtId}`;
+        xfIndex = xfMap.get(xfKey) ?? 0;
       }
-      case "style": {
-        let attrs = `type="${rule.type}" priority="${rule.priority}"`;
-        if (rule.style) {
-          const dxfId = dxfMap.get(JSON.stringify(rule.style));
-          if (dxfId !== void 0) attrs += ` dxfId="${dxfId}"`;
-        }
-        if (rule.operator) attrs += ` operator="${rule.operator}"`;
-        if (rule.text) attrs += ` text="${escapeXml(rule.text)}"`;
-        if (rule.rank !== void 0) attrs += ` rank="${rule.rank}"`;
-        if (rule.percent) attrs += ' percent="1"';
-        if (rule.bottom) attrs += ' bottom="1"';
-        if (rule.aboveAverage === false) attrs += ' aboveAverage="0"';
-        if (rule.timePeriod) attrs += ` timePeriod="${rule.timePeriod}"`;
-        let inner = "";
-        if (rule.formulae) {
-          inner = rule.formulae.map((f) => `<formula>${escapeXml(String(f))}</formula>`).join("");
+      if (xfIndex > 0) attrs += ` s="${xfIndex}"`;
+      if (type) attrs += ` t="${type}"`;
+      let inner = "";
+      if (cell.formula) {
+        if (cell.isArrayFormula && cell.arrayRange) {
+          inner += `<f t="array" ref="${cell.arrayRange}">${escapeXml(cell.formula)}</f>`;
+        } else {
+          inner += `<f>${escapeXml(cell.formula)}</f>`;
         }
-        return `<cfRule ${attrs}>${inner}</cfRule>`;
       }
+      if (value !== void 0) inner += `<v>${escapeXml(String(value))}</v>`;
+      return `<c ${attrs}>${inner}</c>`;
+    }).join("");
+    rows.push(`<row r="${rowNum}"${rowAttrs}${hidden}>${cellsXml}</row>`);
+  }
+  const cols = [];
+  const allCols = /* @__PURE__ */ new Set([...sheet.colWidths.keys(), ...sheet.hiddenCols]);
+  for (const c of Array.from(allCols).sort((a, b) => a - b)) {
+    const w = sheet.colWidths.get(c) ?? sheet.defaultColWidth;
+    const hidden = sheet.hiddenCols.has(c) ? ' hidden="1"' : "";
+    cols.push(`<col min="${c}" max="${c}" width="${w}" customWidth="1"${hidden}/>`);
+  }
+  let mergeXml = "";
+  if (sheet.mergedCells.length > 0) {
+    const merges = sheet.mergedCells.map((r) => `<mergeCell ref="${r}"/>`).join("");
+    mergeXml = `<mergeCells count="${sheet.mergedCells.length}">${merges}</mergeCells>`;
+  }
+  let paneXml = "";
+  let selectionXml = `<selection activeCell="A1" sqref="A1"/>`;
+  if (sheet.freeze) {
+    const activePane = sheet.freeze.col > 0 && sheet.freeze.row > 0 ? "bottomRight" : sheet.freeze.row > 0 ? "bottomLeft" : "topRight";
+    const topLeft = rowColToRef(sheet.freeze.row + 1, sheet.freeze.col + 1);
+    paneXml = `<pane xSplit="${sheet.freeze.col}" ySplit="${sheet.freeze.row}" topLeftCell="${topLeft}" activePane="${activePane}" state="frozen"/>`;
+    selectionXml = `<selection pane="${activePane}" activeCell="${topLeft}" sqref="${topLeft}"/>`;
+  }
+  const tabSelected = isActive ? ' tabSelected="1"' : "";
+  const sheetView = `<sheetView${tabSelected} workbookViewId="0"${!sheet.view.showGridLines ? ' showGridLines="0"' : ""}>${paneXml}${selectionXml}</sheetView>`;
+  let autoFilterXml = "";
+  if (sheet.autoFilter) {
+    let filterCols = "";
+    for (const col of sheet.autoFilter.columns) {
+      if (col.filterValues && col.filterValues.length > 0) {
+        const filters = col.filterValues.map((v) => `<filter val="${escapeXml(v)}"/>`).join("");
+        filterCols += `<filterColumn colId="${col.colIndex}"><filters>${filters}</filters></filterColumn>`;
+      }
+    }
+    autoFilterXml = `<autoFilter ref="${sheet.autoFilter.ref}">${filterCols}</autoFilter>`;
+  }
+  let dvXml = "";
+  if (sheet.dataValidations.length > 0) {
+    const dvEntries = sheet.dataValidations.map((dv) => {
+      let attrs = `sqref="${dv.ref}" type="${dv.type}"`;
+      if (dv.operator) attrs += ` operator="${dv.operator}"`;
+      if (!dv.showDropdown) attrs += ' showDropDown="1"';
+      if (dv.errorStyle) attrs += ` errorStyle="${dv.errorStyle}"`;
+      if (dv.errorTitle) attrs += ` errorTitle="${escapeXml(dv.errorTitle)}"`;
+      if (dv.errorMessage) attrs += ` error="${escapeXml(dv.errorMessage)}"`;
+      if (dv.promptTitle) attrs += ` promptTitle="${escapeXml(dv.promptTitle)}"`;
+      if (dv.promptMessage) attrs += ` prompt="${escapeXml(dv.promptMessage)}"`;
+      let inner = "";
+      if (dv.formula1) inner += `<formula1>${escapeXml(dv.formula1)}</formula1>`;
+      if (dv.formula2) inner += `<formula2>${escapeXml(dv.formula2)}</formula2>`;
+      return `<dataValidation ${attrs}>${inner}</dataValidation>`;
+    }).join("");
+    dvXml = `<dataValidations count="${sheet.dataValidations.length}">${dvEntries}</dataValidations>`;
+  }
+  let cfXml = "";
+  if (sheet.conditionalFormats.length > 0) {
+    cfXml = sheet.conditionalFormats.map((cf) => buildConditionalFormattingXml(cf, dxfMap)).join("");
+  }
+  let hyperlinksXml = "";
+  if (hyperlinkRIds && hyperlinkRIds.size > 0) {
+    const hlEntries = Array.from(hyperlinkRIds.entries()).map(([ref, rId]) => `<hyperlink ref="${ref}" r:id="${rId}"/>`).join("");
+    hyperlinksXml = `<hyperlinks>${hlEntries}</hyperlinks>`;
+  }
+  const drawingXml = drawingRId ? `<drawing r:id="${drawingRId}"/>` : "";
+  let tablePartsXml = "";
+  if (tableRIds && tableRIds.length > 0) {
+    const parts = tableRIds.map((rId) => `<tablePart r:id="${rId}"/>`).join("");
+    tablePartsXml = `<tableParts count="${tableRIds.length}">${parts}</tableParts>`;
+  }
+  const ps = sheet.pageSetup;
+  const hf = sheet.headerFooter;
+  const fitToPage = ps && (ps.fitToWidth !== void 0 || ps.fitToHeight !== void 0);
+  const sheetPrXml = fitToPage ? `<sheetPr><pageSetUpPr fitToPage="1"/></sheetPr>` : "";
+  const marginsXml = (() => {
+    const m = ps?.margins;
+    const left = m?.left ?? 0.7;
+    const right = m?.right ?? 0.7;
+    const top = m?.top ?? 0.75;
+    const bottom = m?.bottom ?? 0.75;
+    const header = m?.header ?? 0.3;
+    const footer = m?.footer ?? 0.3;
+    return `<pageMargins left="${left}" right="${right}" top="${top}" bottom="${bottom}" header="${header}" footer="${footer}"/>`;
+  })();
+  let pageSetupXml = "";
+  if (ps) {
+    const attrs = [];
+    if (ps.paperSize !== void 0) attrs.push(`paperSize="${ps.paperSize}"`);
+    if (ps.scale !== void 0) attrs.push(`scale="${ps.scale}"`);
+    if (ps.fitToWidth !== void 0) attrs.push(`fitToWidth="${ps.fitToWidth}"`);
+    if (ps.fitToHeight !== void 0) attrs.push(`fitToHeight="${ps.fitToHeight}"`);
+    if (ps.orientation) attrs.push(`orientation="${ps.orientation}"`);
+    if (attrs.length > 0) pageSetupXml = `<pageSetup ${attrs.join(" ")}/>`;
+  }
+  let headerFooterXml = "";
+  if (hf) {
+    const rootAttrs = [];
+    if (hf.differentOddEven) rootAttrs.push(`differentOddEven="1"`);
+    if (hf.differentFirst) rootAttrs.push(`differentFirst="1"`);
+    const inner = [];
+    if (hf.oddHeader) inner.push(`<oddHeader>${escapeXml(hf.oddHeader)}</oddHeader>`);
+    if (hf.oddFooter) inner.push(`<oddFooter>${escapeXml(hf.oddFooter)}</oddFooter>`);
+    if (hf.evenHeader) inner.push(`<evenHeader>${escapeXml(hf.evenHeader)}</evenHeader>`);
+    if (hf.evenFooter) inner.push(`<evenFooter>${escapeXml(hf.evenFooter)}</evenFooter>`);
+    if (hf.firstHeader) inner.push(`<firstHeader>${escapeXml(hf.firstHeader)}</firstHeader>`);
+    if (hf.firstFooter) inner.push(`<firstFooter>${escapeXml(hf.firstFooter)}</firstFooter>`);
+    if (inner.length > 0) {
+      const attrStr = rootAttrs.length > 0 ? ` ${rootAttrs.join(" ")}` : "";
+      headerFooterXml = `<headerFooter${attrStr}>${inner.join("")}</headerFooter>`;
     }
-  }).join("");
-  return `<conditionalFormatting sqref="${cf.ref}">${rules}</conditionalFormatting>`;
-}
-function buildDxfXml(style) {
-  let inner = "";
-  if (style.fontBold || style.fontItalic || style.fontColor) {
-    let fontParts = "";
-    if (style.fontBold) fontParts += "<b/>";
-    if (style.fontItalic) fontParts += "<i/>";
-    if (style.fontColor) fontParts += `<color rgb="${hexToArgb(style.fontColor)}"/>`;
-    inner += `<font>${fontParts}</font>`;
   }
-  if (style.backgroundColor) {
-    inner += `<fill><patternFill><bgColor rgb="${hexToArgb(style.backgroundColor)}"/></patternFill></fill>`;
+  let dimensionRef = "A1";
+  if (sortedRows.length > 0) {
+    let minCol = Infinity, maxCol = 0;
+    const minRow = sortedRows[0];
+    const maxRow = sortedRows[sortedRows.length - 1];
+    for (const rowNum of sortedRows) {
+      const cells = rowMap.get(rowNum);
+      for (const { col } of cells) {
+        if (col < minCol) minCol = col;
+        if (col > maxCol) maxCol = col;
+      }
+    }
+    dimensionRef = `${rowColToRef(minRow, minCol)}:${rowColToRef(maxRow, maxCol)}`;
   }
-  return `<dxf>${inner}</dxf>`;
-}
-function getImageExtension(dataUrl) {
-  if (dataUrl.startsWith("data:image/png")) return "png";
-  if (dataUrl.startsWith("data:image/jpeg") || dataUrl.startsWith("data:image/jpg")) return "jpeg";
-  if (dataUrl.startsWith("data:image/gif")) return "gif";
-  return "png";
-}
-function dataUrlToBytes(dataUrl) {
-  const match = dataUrl.match(/^data:[^;]+;base64,(.+)$/);
-  if (!match) return null;
-  const binary = atob(match[1]);
-  const bytes = new Uint8Array(binary.length);
-  for (let i2 = 0; i2 < binary.length; i2++) bytes[i2] = binary.charCodeAt(i2);
-  return bytes;
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+  xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+${sheetPrXml}<dimension ref="${dimensionRef}"/>
+<sheetViews>${sheetView}</sheetViews>
+<sheetFormatPr defaultRowHeight="${sheet.defaultRowHeight}" defaultColWidth="${sheet.defaultColWidth}"/>
+${cols.length > 0 ? `<cols>${cols.join("")}</cols>` : ""}
+<sheetData>
+${rows.join("\n")}
+</sheetData>
+${autoFilterXml}${mergeXml}${cfXml}${dvXml}${hyperlinksXml}${marginsXml}${pageSetupXml}${headerFooterXml}${drawingXml}${tablePartsXml}
+</worksheet>`;
 }
-function escapeXml(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+function getCellType(cell, ssIndex) {
+  if (cell.error) return "e";
+  if (cell.formula && typeof cell.value === "string") return "str";
+  if (typeof cell.value === "string" && ssIndex.has(cell.value)) return "s";
+  if (typeof cell.value === "boolean") return "b";
+  return void 0;
 }
-
-// ../xlsx/src/style_helpers.ts
-function border(style = "thin", color = "#000000") {
-  return { width: 1, style, color };
+function getCellValue(cell, ssIndex) {
+  if (cell.value === null) return void 0;
+  if (cell.error) return cell.error;
+  if (cell.formula && typeof cell.value === "string") return cell.value;
+  if (typeof cell.value === "string") {
+    const idx = ssIndex.get(cell.value);
+    return idx !== void 0 ? idx : cell.value;
+  }
+  if (typeof cell.value === "boolean") return cell.value ? 1 : 0;
+  return cell.value;
 }
-function allBorders(style = "thin", color = "#000000") {
-  const b = border(style, color);
-  return { borderTop: b, borderRight: b, borderBottom: b, borderLeft: b };
+function quoteSheetName(name) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? name : `'${name.replace(/'/g, "''")}'`;
 }
-
-// ../xlsx/src/pivot_recompute.ts
-var TOTAL_LABEL = "Grand Total";
-function recomputePivot(table, cache, source) {
-  const records = filterByPageAxis(table, cache, source.records);
-  const rowTuples = distinctTuples(records, table.rowFieldIndices);
-  const colTuples = distinctTuples(records, table.colFieldIndices);
-  const groupKey = (rec) => JSON.stringify([
-    tupleOf(rec, table.rowFieldIndices),
-    tupleOf(rec, table.colFieldIndices)
-  ]);
-  const groups = /* @__PURE__ */ new Map();
-  for (const rec of records) {
-    const key = groupKey(rec);
-    let bucket = groups.get(key);
-    if (!bucket) {
-      bucket = [];
-      groups.set(key, bucket);
+function buildWorkbookXml(workbook, pivotInfo) {
+  const sheets = workbook.sheets.map(
+    (s, i2) => `<sheet name="${escapeXml(s.name)}" sheetId="${i2 + 1}" r:id="rId${i2 + 1}"/>`
+  ).join("\n");
+  const nameEntries = [];
+  for (const [name, value] of workbook.namedRanges) {
+    nameEntries.push(`<definedName name="${escapeXml(name)}">${escapeXml(value)}</definedName>`);
+  }
+  workbook.sheets.forEach((s, i2) => {
+    const pt = s.printTitles;
+    if (!pt || !pt.repeatRows && !pt.repeatCols) return;
+    const parts = [];
+    const sheetName = quoteSheetName(s.name);
+    if (pt.repeatCols) {
+      const [start, end] = pt.repeatCols;
+      parts.push(`${sheetName}!$${colNumToLetters(start)}:$${colNumToLetters(end)}`);
     }
-    bucket.push(rec);
+    if (pt.repeatRows) {
+      const [start, end] = pt.repeatRows;
+      parts.push(`${sheetName}!$${start}:$${end}`);
+    }
+    nameEntries.push(
+      `<definedName name="_xlnm.Print_Titles" localSheetId="${i2}">${escapeXml(parts.join(","))}</definedName>`
+    );
+  });
+  const definedNames = nameEntries.length > 0 ? `
+<definedNames>
+${nameEntries.join("\n")}
+</definedNames>` : "";
+  let pivotCachesBlock = "";
+  if (pivotInfo && pivotInfo.cachesByWorkbook.size > 0) {
+    const baseRId = workbook.sheets.length + 3;
+    const cacheIds = [...pivotInfo.cachesByWorkbook.keys()].sort((a, b) => a - b);
+    const items = cacheIds.map((cacheId, i2) => `<pivotCache cacheId="${cacheId}" r:id="rId${baseRId + i2}"/>`).join("\n");
+    pivotCachesBlock = `
+<pivotCaches>
+${items}
+</pivotCaches>`;
   }
-  return buildGrid(table, source, rowTuples, colTuples, groups, records);
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+  xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+<bookViews>
+<workbookView activeTab="${workbook.activeSheetIndex}"/>
+</bookViews>
+<sheets>
+${sheets}
+</sheets>${definedNames}${pivotCachesBlock}
+<calcPr fullCalcOnLoad="1"/>
+</workbook>`;
 }
-function filterByPageAxis(table, cache, records) {
-  const filters = [];
-  for (const fi of table.pageFieldIndices) {
-    const cfg = table.fields[fi];
-    if (cfg?.selectedPageItem == null) continue;
-    const cacheField = cache.fields[fi];
-    if (!cacheField) continue;
-    const allowed = cacheField.items[cfg.selectedPageItem];
-    if (allowed) filters.push({ fieldIndex: fi, allowed });
-  }
-  if (filters.length === 0) return records;
-  return records.filter(
-    (rec) => filters.every(
-      ({ fieldIndex, allowed }) => cellMatchesItem(rec[fieldIndex], allowed)
-    )
+function buildWorkbookRels(workbook, pivotInfo) {
+  const rels = workbook.sheets.map(
+    (_, i2) => `<Relationship Id="rId${i2 + 1}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet${i2 + 1}.xml"/>`
   );
-}
-function cellMatchesItem(cell, item) {
-  switch (item.kind) {
-    case "string":
-      return typeof cell === "string" && cell === item.value;
-    case "number":
-      return typeof cell === "number" && cell === item.value;
-    case "boolean":
-      return typeof cell === "boolean" && cell === item.value;
-    case "date":
-      return typeof cell === "string" && cell === item.value;
-    case "missing":
-      return cell === void 0 || cell === null || cell === "";
-    case "error":
-      return typeof cell === "string" && cell === item.value;
+  rels.push(`<Relationship Id="rId${workbook.sheets.length + 1}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>`);
+  rels.push(`<Relationship Id="rId${workbook.sheets.length + 2}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" Target="sharedStrings.xml"/>`);
+  if (pivotInfo && pivotInfo.cachesByWorkbook.size > 0) {
+    const baseRId = workbook.sheets.length + 3;
+    const cacheIds = [...pivotInfo.cachesByWorkbook.keys()].sort((a, b) => a - b);
+    cacheIds.forEach((cacheId, i2) => {
+      const target = pivotInfo.cachesByWorkbook.get(cacheId);
+      if (!target) return;
+      rels.push(
+        `<Relationship Id="rId${baseRId + i2}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition" Target="${escapeXml(target)}"/>`
+      );
+    });
   }
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+${rels.join("\n")}
+</Relationships>`;
 }
-function tupleOf(rec, indices) {
-  return indices.map((i2) => rec[i2] ?? null);
+function buildContentTypes(sheetCount, extraTypes = []) {
+  const sheetTypes = Array.from(
+    { length: sheetCount },
+    (_, i2) => `<Override PartName="/xl/worksheets/sheet${i2 + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`
+  ).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+<Default Extension="xml" ContentType="application/xml"/>
+<Default Extension="png" ContentType="image/png"/>
+<Default Extension="jpeg" ContentType="image/jpeg"/>
+<Default Extension="jpg" ContentType="image/jpeg"/>
+<Default Extension="gif" ContentType="image/gif"/>
+<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>
+${sheetTypes}
+<Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>
+<Override PartName="/xl/sharedStrings.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml"/>
+<Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/>
+<Override PartName="/docProps/app.xml" ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml"/>
+${extraTypes.join("\n")}
+</Types>`;
 }
-function distinctTuples(records, indices) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const rec of records) {
-    const t = tupleOf(rec, indices);
-    const key = JSON.stringify(t);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push(t);
-  }
-  out.sort((a, b) => {
-    for (let i2 = 0; i2 < Math.max(a.length, b.length); i2++) {
-      const av = a[i2];
-      const bv = b[i2];
-      if (av === bv) continue;
-      const as = av === null || av === void 0 ? "" : String(av);
-      const bs = bv === null || bv === void 0 ? "" : String(bv);
-      if (as < bs) return -1;
-      if (as > bs) return 1;
-    }
-    return 0;
-  });
-  return out;
+function buildRootRels() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>
+<Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/>
+<Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties" Target="docProps/app.xml"/>
+</Relationships>`;
+}
+function buildCoreProps() {
+  const now = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties"
+  xmlns:dc="http://purl.org/dc/elements/1.1/"
+  xmlns:dcterms="http://purl.org/dc/terms/"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+<dcterms:created xsi:type="dcterms:W3CDTF">${now}</dcterms:created>
+<dcterms:modified xsi:type="dcterms:W3CDTF">${now}</dcterms:modified>
+</cp:coreProperties>`;
 }
-function aggregate(values2, fn) {
-  const numeric = values2.filter((v) => typeof v === "number");
-  switch (fn) {
-    case "count":
-      return values2.filter((v) => v !== null && v !== void 0 && v !== "").length;
-    case "countNums":
-      return numeric.length;
-    case "sum":
-      return numeric.reduce((a, b) => a + b, 0);
-    case "average":
-      if (numeric.length === 0) return null;
-      return numeric.reduce((a, b) => a + b, 0) / numeric.length;
-    case "min":
-      return numeric.length === 0 ? null : Math.min(...numeric);
-    case "max":
-      return numeric.length === 0 ? null : Math.max(...numeric);
-    case "product":
-      return numeric.length === 0 ? null : numeric.reduce((a, b) => a * b, 1);
-  }
+function buildAppProps() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties">
+<Application>Microsoft Excel</Application>
+</Properties>`;
 }
-function buildGrid(table, source, rowTuples, colTuples, groups, allRecords) {
-  const numRowFields = table.rowFieldIndices.length;
-  const numColFields = table.colFieldIndices.length;
-  const numDataFields = Math.max(table.dataFields.length, 1);
-  const showRowGrand = table.display.colGrandTotals;
-  const showColGrand = table.display.rowGrandTotals;
-  const rowLabelCols = Math.max(numRowFields, 1);
-  const colHeaderRows = numColFields + (numDataFields > 0 ? 1 : 0);
-  const headerRows = Math.max(colHeaderRows, 1);
-  const dataCols = colTuples.length * numDataFields;
-  const totalCols = rowLabelCols + dataCols + (showColGrand ? numDataFields : 0);
-  const totalRows = headerRows + rowTuples.length + (showRowGrand ? 1 : 0);
-  const cells = [];
-  for (let r = 0; r < totalRows; r++) {
-    cells.push(new Array(totalCols).fill({ kind: "blank" }));
+var CHART_TYPE_MAP2 = {
+  bar: "c:barChart",
+  col: "c:barChart",
+  line: "c:lineChart",
+  pie: "c:pieChart",
+  doughnut: "c:doughnutChart",
+  area: "c:areaChart",
+  scatter: "c:scatterChart",
+  bubble: "c:bubbleChart",
+  radar: "c:radarChart",
+  stock: "c:stockChart",
+  surface: "c:surfaceChart"
+};
+function buildSeriesXml(s, idx, chartType, categories) {
+  let nameXml = "";
+  if (s.name) nameXml = `<c:tx><c:strRef><c:strCache><c:ptCount val="1"/><c:pt idx="0"><c:v>${escapeXml(s.name)}</c:v></c:pt></c:strCache></c:strRef></c:tx>`;
+  let colorXml = "";
+  if (s.color) colorXml = `<c:spPr><a:solidFill><a:srgbClr val="${hexToOoxmlRgb(s.color)}"/></a:solidFill></c:spPr>`;
+  const valTag = chartType === "scatter" || chartType === "bubble" ? "c:yVal" : "c:val";
+  const valPts = s.values.map((v, i2) => `<c:pt idx="${i2}"><c:v>${v}</c:v></c:pt>`).join("");
+  const valXml = `<${valTag}><c:numRef><c:numCache><c:ptCount val="${s.values.length}"/>${valPts}</c:numCache></c:numRef></${valTag}>`;
+  let catXml = "";
+  if (categories && categories.length > 0) {
+    const catTag = chartType === "scatter" || chartType === "bubble" ? "c:xVal" : "c:cat";
+    const catPts = categories.map((c, i2) => `<c:pt idx="${i2}"><c:v>${escapeXml(c)}</c:v></c:pt>`).join("");
+    catXml = `<${catTag}><c:strRef><c:strCache><c:ptCount val="${categories.length}"/>${catPts}</c:strCache></c:strRef></${catTag}>`;
   }
-  for (let level = 0; level < numColFields; level++) {
-    let col = rowLabelCols;
-    for (const tuple of colTuples) {
-      const text = formatCellLabel(tuple[level]);
-      for (let i2 = 0; i2 < numDataFields; i2++) {
-        cells[level][col + i2] = { kind: "colHeader", depth: level, text };
-      }
-      col += numDataFields;
-    }
+  let bubbleXml = "";
+  if (s.bubbleSizes) {
+    const bPts = s.bubbleSizes.map((v, i2) => `<c:pt idx="${i2}"><c:v>${v}</c:v></c:pt>`).join("");
+    bubbleXml = `<c:bubbleSize><c:numRef><c:numCache><c:ptCount val="${s.bubbleSizes.length}"/>${bPts}</c:numCache></c:numRef></c:bubbleSize>`;
   }
-  if (numDataFields > 0) {
-    const labelRow = colHeaderRows - 1;
-    let col = rowLabelCols;
-    for (let _t = 0; _t < colTuples.length; _t++) {
-      for (let d = 0; d < table.dataFields.length; d++) {
-        cells[labelRow][col + d] = {
-          kind: "valueLabel",
-          text: table.dataFields[d].name
-        };
-      }
-      col += numDataFields;
-    }
-    if (showColGrand) {
-      for (let d = 0; d < table.dataFields.length; d++) {
-        cells[labelRow][rowLabelCols + dataCols + d] = {
-          kind: "valueLabel",
-          text: table.dataFields[d].name
-        };
-      }
-    }
+  return `<c:ser><c:idx val="${idx}"/><c:order val="${idx}"/>${nameXml}${colorXml}${catXml}${valXml}${bubbleXml}</c:ser>`;
+}
+function buildChartTypeElement(chartType, seriesXml, needsAxIds) {
+  const chartTag = CHART_TYPE_MAP2[chartType] ?? "c:barChart";
+  const isBar = chartType === "bar";
+  let barDir = "";
+  if (chartTag === "c:barChart") {
+    barDir = isBar ? '<c:barDir val="bar"/>' : '<c:barDir val="col"/>';
   }
-  for (let r = 0; r < rowTuples.length; r++) {
-    const rowTuple = rowTuples[r];
-    const gridRow = headerRows + r;
-    for (let level = 0; level < numRowFields; level++) {
-      cells[gridRow][level] = {
-        kind: "rowHeader",
-        depth: level,
-        text: formatCellLabel(rowTuple[level])
-      };
-    }
-    for (let c = 0; c < colTuples.length; c++) {
-      const colTuple = colTuples[c];
-      const groupRecords = groups.get(JSON.stringify([rowTuple, colTuple])) ?? [];
-      for (let d = 0; d < table.dataFields.length; d++) {
-        const df = table.dataFields[d];
-        const values2 = groupRecords.map((rec) => rec[df.fieldIndex]);
-        cells[gridRow][rowLabelCols + c * numDataFields + d] = {
-          kind: "value",
-          value: aggregate(values2, df.subtotal),
-          numFmt: df.numFmt
-        };
-      }
-    }
-    if (showColGrand) {
-      const rowOnly = allRecords.filter(
-        (rec) => sameTuple(tupleOf(rec, table.rowFieldIndices), rowTuple)
-      );
-      for (let d = 0; d < table.dataFields.length; d++) {
-        const df = table.dataFields[d];
-        cells[gridRow][rowLabelCols + dataCols + d] = {
-          kind: "rowTotal",
-          value: aggregate(
-            rowOnly.map((rec) => rec[df.fieldIndex]),
-            df.subtotal
-          )
-        };
-      }
-    }
+  let grouping = "";
+  if (chartTag === "c:barChart") {
+    grouping = '<c:grouping val="clustered"/>';
+  } else if (chartTag === "c:lineChart" || chartTag === "c:areaChart") {
+    grouping = '<c:grouping val="clustered"/>';
   }
-  if (showRowGrand) {
-    const gridRow = headerRows + rowTuples.length;
-    cells[gridRow][0] = { kind: "totalLabel", text: TOTAL_LABEL };
-    for (let c = 0; c < colTuples.length; c++) {
-      const colTuple = colTuples[c];
-      const colOnly = allRecords.filter(
-        (rec) => sameTuple(tupleOf(rec, table.colFieldIndices), colTuple)
-      );
-      for (let d = 0; d < table.dataFields.length; d++) {
-        const df = table.dataFields[d];
-        cells[gridRow][rowLabelCols + c * numDataFields + d] = {
-          kind: "colTotal",
-          value: aggregate(
-            colOnly.map((rec) => rec[df.fieldIndex]),
-            df.subtotal
-          )
-        };
-      }
-    }
-    if (showColGrand) {
-      for (let d = 0; d < table.dataFields.length; d++) {
-        const df = table.dataFields[d];
-        cells[gridRow][rowLabelCols + dataCols + d] = {
-          kind: "grandTotal",
-          value: aggregate(
-            allRecords.map((rec) => rec[df.fieldIndex]),
-            df.subtotal
-          )
-        };
+  const axIds = needsAxIds ? '<c:axId val="1"/><c:axId val="2"/>' : "";
+  return `<${chartTag}>${barDir}${grouping}${seriesXml}${axIds}</${chartTag}>`;
+}
+function buildChartXml(chart) {
+  const needsAxIds = chart.chartType !== "pie" && chart.chartType !== "doughnut";
+  let plotArea;
+  if (chart.chartType === "combo") {
+    const groups = /* @__PURE__ */ new Map();
+    chart.series.forEach((s, idx) => {
+      const sType = s.seriesChartType ?? "col";
+      let group = groups.get(sType);
+      if (!group) {
+        group = [];
+        groups.set(sType, group);
       }
+      group.push({ series: s, idx });
+    });
+    let chartElements = "";
+    for (const [groupType, groupSeries] of groups) {
+      const groupSeriesXml = groupSeries.map(
+        ({ series, idx }) => buildSeriesXml(series, idx, groupType, chart.categories)
+      ).join("");
+      chartElements += buildChartTypeElement(groupType, groupSeriesXml, true);
     }
+    plotArea = `<c:plotArea><c:layout/>${chartElements}`;
+  } else {
+    const seriesXml = chart.series.map(
+      (s, idx) => buildSeriesXml(s, idx, chart.chartType, chart.categories)
+    ).join("");
+    plotArea = `<c:plotArea><c:layout/>${buildChartTypeElement(chart.chartType, seriesXml, needsAxIds)}`;
   }
-  void source;
-  return {
-    cells,
-    headerRows,
-    rowLabelCols,
-    rows: totalRows,
-    cols: totalCols
-  };
-}
-function sameTuple(a, b) {
-  if (a.length !== b.length) return false;
-  for (let i2 = 0; i2 < a.length; i2++) {
-    if (a[i2] !== b[i2]) {
-      const an = a[i2] === void 0 || a[i2] === null || a[i2] === "";
-      const bn = b[i2] === void 0 || b[i2] === null || b[i2] === "";
-      if (!(an && bn)) return false;
+  if (chart.chartType !== "pie" && chart.chartType !== "doughnut") {
+    const axes = chart.axes ?? [{ type: "category" }, { type: "value" }];
+    for (let i2 = 0; i2 < axes.length; i2++) {
+      const ax = axes[i2];
+      const axId = i2 + 1;
+      const crossId = i2 === 0 ? 2 : 1;
+      let axTag;
+      switch (ax.type) {
+        case "value":
+          axTag = "c:valAx";
+          break;
+        case "date":
+          axTag = "c:dateAx";
+          break;
+        case "series":
+          axTag = "c:serAx";
+          break;
+        default:
+          axTag = "c:catAx";
+          break;
+      }
+      let titleXml2 = "";
+      if (ax.title) titleXml2 = `<c:title><c:tx><c:rich><a:bodyPr/><a:lstStyle/><a:p><a:r><a:t>${escapeXml(ax.title)}</a:t></a:r></a:p></c:rich></c:tx></c:title>`;
+      let scalingXml = '<c:scaling><c:orientation val="minMax"/>';
+      if (ax.min !== void 0) scalingXml += `<c:min val="${ax.min}"/>`;
+      if (ax.max !== void 0) scalingXml += `<c:max val="${ax.max}"/>`;
+      scalingXml += "</c:scaling>";
+      const numFmt = ax.numFmt ? `<c:numFmt formatCode="${escapeXml(ax.numFmt)}" sourceLinked="0"/>` : "";
+      plotArea += `<${axTag}><c:axId val="${axId}"/>${scalingXml}${titleXml2}${numFmt}<c:crossAx val="${crossId}"/></${axTag}>`;
     }
   }
-  return true;
+  plotArea += "</c:plotArea>";
+  let titleXml = "";
+  if (chart.title) {
+    titleXml = `<c:title><c:tx><c:rich><a:bodyPr/><a:lstStyle/><a:p><a:r><a:t>${escapeXml(chart.title)}</a:t></a:r></a:p></c:rich></c:tx></c:title>`;
+  }
+  let legendXml = "";
+  if (chart.legendPosition && chart.legendPosition !== "none") {
+    const posMap = { top: "t", bottom: "b", left: "l", right: "r" };
+    legendXml = `<c:legend><c:legendPos val="${posMap[chart.legendPosition] ?? "b"}"/></c:legend>`;
+  }
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<c:chartSpace xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+<c:chart>${titleXml}${plotArea}${legendXml}</c:chart>
+</c:chartSpace>`;
 }
-function formatCellLabel(v) {
-  if (v === void 0 || v === null || v === "") return "(blank)";
-  if (typeof v === "boolean") return v ? "TRUE" : "FALSE";
-  return String(v);
+function buildAnchorPosition(pos) {
+  return `<xdr:col>${pos.col}</xdr:col><xdr:colOff>${pos.colOffset ?? 0}</xdr:colOff><xdr:row>${pos.row}</xdr:row><xdr:rowOff>${pos.rowOffset ?? 0}</xdr:rowOff>`;
 }
-
-// ../xlsx/src/pivot_model.ts
-var PivotTableModel = class {
-  constructor(config, cache) {
-    this.config = config;
-    this.cache = cache;
+function buildChartAnchorXml(chart, rId) {
+  return `<xdr:twoCellAnchor>
+<xdr:from>${buildAnchorPosition(chart.anchor.from)}</xdr:from>
+<xdr:to>${buildAnchorPosition(chart.anchor.to)}</xdr:to>
+<xdr:graphicFrame macro="">
+<xdr:nvGraphicFramePr><xdr:cNvPr id="0" name="Chart"/><xdr:cNvGraphicFramePr/></xdr:nvGraphicFramePr>
+<xdr:xfrm><a:off x="0" y="0"/><a:ext cx="0" cy="0"/></xdr:xfrm>
+<a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/chart"><c:chart xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" r:id="${rId}"/></a:graphicData></a:graphic>
+</xdr:graphicFrame>
+<xdr:clientData/>
+</xdr:twoCellAnchor>`;
+}
+function buildImageAnchorXml(image, rId) {
+  return `<xdr:twoCellAnchor editAs="oneCell">
+<xdr:from>${buildAnchorPosition(image.tl)}</xdr:from>
+<xdr:to>${buildAnchorPosition(image.br)}</xdr:to>
+<xdr:pic>
+<xdr:nvPicPr><xdr:cNvPr id="0" name="Image"/><xdr:cNvPicPr/></xdr:nvPicPr>
+<xdr:blipFill><a:blip xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" r:embed="${rId}"/><a:stretch><a:fillRect/></a:stretch></xdr:blipFill>
+<xdr:spPr><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></xdr:spPr>
+</xdr:pic>
+<xdr:clientData/>
+</xdr:twoCellAnchor>`;
+}
+function buildShapeAnchorXml(drawing) {
+  let fillXml = "";
+  if (drawing.fillColor) fillXml = `<a:solidFill><a:srgbClr val="${hexToOoxmlRgb(drawing.fillColor)}"/></a:solidFill>`;
+  let outlineXml = "";
+  if (drawing.outlineColor) {
+    const w = Math.round((drawing.outlineWidth ?? 1) * 12700);
+    outlineXml = `<a:ln w="${w}"><a:solidFill><a:srgbClr val="${hexToOoxmlRgb(drawing.outlineColor)}"/></a:solidFill></a:ln>`;
   }
-  /**
-   * Recompute the pivot result from the workbook's current source data.
-   * Callers are responsible for triggering recomputation; the model does
-   * not subscribe to workbook changes itself.
-   */
-  recompute(workbook) {
-    const source = readSourceData(workbook, this.cache);
-    if (!source) {
-      this.result = void 0;
-      return;
+  const geom = drawing.geometry ?? "rect";
+  let textXml = "";
+  if (drawing.text) textXml = `<xdr:txBody><a:bodyPr/><a:lstStyle/><a:p><a:r><a:t>${escapeXml(drawing.text)}</a:t></a:r></a:p></xdr:txBody>`;
+  return `<xdr:twoCellAnchor>
+<xdr:from>${buildAnchorPosition(drawing.anchor.from)}</xdr:from>
+<xdr:to>${buildAnchorPosition(drawing.anchor.to)}</xdr:to>
+<xdr:sp><xdr:nvSpPr><xdr:cNvPr id="0" name="Shape"/><xdr:cNvSpPr/></xdr:nvSpPr>
+<xdr:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="0" cy="0"/></a:xfrm><a:prstGeom prst="${geom}"><a:avLst/></a:prstGeom>${fillXml}${outlineXml}</xdr:spPr>
+${textXml}</xdr:sp>
+<xdr:clientData/>
+</xdr:twoCellAnchor>`;
+}
+function buildTableXml(table, tableId) {
+  const colsXml = table.columns.map((col) => {
+    let inner = "";
+    if (col.totalsFunction) inner += `<totalsRowFunction>${escapeXml(col.totalsFunction)}</totalsRowFunction>`;
+    if (col.totalsFormula) inner += `<totalsRowFormula>${escapeXml(col.totalsFormula)}</totalsRowFormula>`;
+    return `<tableColumn id="${col.id}" name="${escapeXml(col.name)}">${inner}</tableColumn>`;
+  }).join("");
+  const autoFilterXml = table.autoFilter ? `<autoFilter ref="${escapeXml(table.ref)}"/>` : "";
+  const styleName = table.styleName ?? "TableStyleMedium2";
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<table xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" id="${tableId}" name="${escapeXml(table.name)}" displayName="${escapeXml(table.displayName)}" ref="${escapeXml(table.ref)}" totalsRowCount="${table.totalsRow ? 1 : 0}">
+${autoFilterXml}
+<tableColumns count="${table.columns.length}">${colsXml}</tableColumns>
+<tableStyleInfo name="${escapeXml(styleName)}" showFirstColumn="0" showLastColumn="0" showRowStripes="1" showColumnStripes="0"/>
+</table>`;
+}
+function buildConditionalFormattingXml(cf, dxfMap) {
+  const rules = cf.rules.map((rule) => {
+    switch (rule.ruleType) {
+      case "colorScale": {
+        const count = rule.colors.length;
+        const cfvos = count === 2 ? '<cfvo type="min"/><cfvo type="max"/>' : '<cfvo type="min"/><cfvo type="percentile" val="50"/><cfvo type="max"/>';
+        const colors = rule.colors.map((c) => `<color rgb="${hexToArgb(c)}"/>`).join("");
+        return `<cfRule type="colorScale" priority="${rule.priority}"><colorScale>${cfvos}${colors}</colorScale></cfRule>`;
+      }
+      case "dataBar": {
+        const showVal = rule.showValue ? "1" : "0";
+        return `<cfRule type="dataBar" priority="${rule.priority}"><dataBar minLength="${rule.minLength}" maxLength="${rule.maxLength}" showValue="${showVal}"><cfvo type="min"/><cfvo type="max"/><color rgb="${hexToArgb(rule.color)}"/></dataBar></cfRule>`;
+      }
+      case "iconSet": {
+        const thresholds = rule.thresholds.map((t) => {
+          if (t.type === "min" || t.type === "autoMin") return '<cfvo type="min"/>';
+          if (t.type === "max" || t.type === "autoMax") return '<cfvo type="max"/>';
+          return `<cfvo type="${t.type}" val="${t.value ?? 0}"/>`;
+        }).join("");
+        const showVal = rule.showValue ? "" : ' showValue="0"';
+        const reverse = rule.reverse ? ' reverse="1"' : "";
+        return `<cfRule type="iconSet" priority="${rule.priority}"><iconSet iconSet="${rule.iconSet}"${showVal}${reverse}>${thresholds}</iconSet></cfRule>`;
+      }
+      case "style": {
+        let attrs = `type="${rule.type}" priority="${rule.priority}"`;
+        if (rule.style) {
+          const dxfId = dxfMap.get(JSON.stringify(rule.style));
+          if (dxfId !== void 0) attrs += ` dxfId="${dxfId}"`;
+        }
+        if (rule.operator) attrs += ` operator="${rule.operator}"`;
+        if (rule.text) attrs += ` text="${escapeXml(rule.text)}"`;
+        if (rule.rank !== void 0) attrs += ` rank="${rule.rank}"`;
+        if (rule.percent) attrs += ' percent="1"';
+        if (rule.bottom) attrs += ' bottom="1"';
+        if (rule.aboveAverage === false) attrs += ' aboveAverage="0"';
+        if (rule.timePeriod) attrs += ` timePeriod="${rule.timePeriod}"`;
+        let inner = "";
+        if (rule.formulae) {
+          inner = rule.formulae.map((f) => `<formula>${escapeXml(String(f))}</formula>`).join("");
+        }
+        return `<cfRule ${attrs}>${inner}</cfRule>`;
+      }
     }
-    this.result = recomputePivot(this.config, this.cache, source);
-  }
-};
-function readSourceData(workbook, cache) {
-  if (cache.source.type !== "worksheet") return void 0;
-  const source = cache.source;
-  const sheet = workbook.sheets.find((s) => s.name === source.sheetName);
-  if (!sheet) return void 0;
-  const range = parseRange(source.ref);
-  if (!range) return void 0;
-  const header = [];
-  for (let col = range.startCol; col <= range.endCol; col++) {
-    const cell = sheet.getCell(rowColToRef(range.startRow, col));
-    header.push(formatHeader(cell?.value));
+  }).join("");
+  return `<conditionalFormatting sqref="${cf.ref}">${rules}</conditionalFormatting>`;
+}
+function buildDxfXml(style) {
+  let inner = "";
+  if (style.fontBold || style.fontItalic || style.fontColor) {
+    let fontParts = "";
+    if (style.fontBold) fontParts += "<b/>";
+    if (style.fontItalic) fontParts += "<i/>";
+    if (style.fontColor) fontParts += `<color rgb="${hexToArgb(style.fontColor)}"/>`;
+    inner += `<font>${fontParts}</font>`;
   }
-  const records = [];
-  for (let row = range.startRow + 1; row <= range.endRow; row++) {
-    const rec = [];
-    for (let col = range.startCol; col <= range.endCol; col++) {
-      const cell = sheet.getCell(rowColToRef(row, col));
-      rec.push(coerceValue(cell?.value));
-    }
-    records.push(rec);
+  if (style.backgroundColor) {
+    inner += `<fill><patternFill><bgColor rgb="${hexToArgb(style.backgroundColor)}"/></patternFill></fill>`;
   }
-  return { header, records };
+  return `<dxf>${inner}</dxf>`;
 }
-function formatHeader(v) {
-  if (v === void 0 || v === null) return "";
-  return String(v);
+function getImageExtension(dataUrl) {
+  if (dataUrl.startsWith("data:image/png")) return "png";
+  if (dataUrl.startsWith("data:image/jpeg") || dataUrl.startsWith("data:image/jpg")) return "jpeg";
+  if (dataUrl.startsWith("data:image/gif")) return "gif";
+  return "png";
 }
-function coerceValue(v) {
-  if (v === void 0 || v === null) return void 0;
-  if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
-    return v;
-  }
-  return String(v);
+function dataUrlToBytes(dataUrl) {
+  const match = dataUrl.match(/^data:[^;]+;base64,(.+)$/);
+  if (!match) return null;
+  const binary = atob(match[1]);
+  const bytes = new Uint8Array(binary.length);
+  for (let i2 = 0; i2 < binary.length; i2++) bytes[i2] = binary.charCodeAt(i2);
+  return bytes;
 }
-function parseRange(ref) {
-  const range = ref.includes("!") ? ref.split("!")[1] : ref;
-  const cleaned = range.replace(/\$/g, "");
-  const m = cleaned.match(/^([A-Z]+\d+)(?::([A-Z]+\d+))?$/);
-  if (!m) return void 0;
-  const start = refToRowCol(m[1]);
-  if (!start) return void 0;
-  const endRef = m[2] ?? m[1];
-  const end = refToRowCol(endRef);
-  if (!end) return void 0;
-  return {
-    startRow: start.row,
-    startCol: start.col,
-    endRow: end.row,
-    endCol: end.col
-  };
+
+// ../xlsx/src/style_helpers.ts
+function border(style = "thin", color = "#000000") {
+  return { width: 1, style, color };
+}
+function allBorders(style = "thin", color = "#000000") {
+  const b = border(style, color);
+  return { borderTop: b, borderRight: b, borderBottom: b, borderLeft: b };
 }
 
 // ../xlsx/src/workbook_model.ts
@@ -47923,6 +48905,8 @@ async function runDocxCommand(subcommand, toolArgs, restArgs) {
 }
 
 // src/cli.ts
+dns.setDefaultResultOrder("ipv4first");
+net2.setDefaultAutoSelectFamilyAttemptTimeout(2e3);
 function printHelp() {
   console.log(`Lotics CLI v${VERSION} \u2014 AI agent interface for Lotics
 
@@ -47979,9 +48963,21 @@ COMMANDS
   lotics app deploy [-m <message>]     Build + upload current dir as a new version
                                        (code + queries only \u2014 workflow bindings are
                                        managed by set_app_workflow / remove_app_workflow)
+  lotics app codegen [path]            Regenerate .lotics/* (types + field/option ids)
+                                       from the manifest + workspace schema \u2014 no deploy
+  lotics app workflow run <alias> '<json>'  Execute a bound app workflow end-to-end
+                                       (inputs: inline JSON, @file, or stdin;
+                                        --print-created reports created records +
+                                        a paste-ready cleanup plan; --cleanup also
+                                        deletes those records \u2014 NOT a rollback)
+  lotics app workflow set <alias>      Push the edited src/workflows/<alias>.ts body
+                                       through set_app_workflow (server verifies)
+  lotics app workflow pull             Rewrite src/workflows/*.ts from the server
   lotics app subdomain <new-subdomain> Rename the app's public <slug>.lotics.app address
   lotics app rename "<new name>"       Rename the app's display name (launcher title)
   lotics app dev [path]                Run the app locally with HMR (RPC forwarded to prod)
+  lotics ui link <component> [--remove] Dev-link @lotics/ui to the monorepo's
+                                       packages/ui/src for live HMR (monorepo only)
   lotics xlsx <subcommand> ...         Read/write/edit .xlsx files on your local filesystem
                                        (uses the bundled Lotics xlsx engine; prefer over
                                        npm xlsx/exceljs for round-trip fidelity)
@@ -48341,6 +49337,34 @@ async function main() {
     await runDocxCommand(subcommand, toolArgs, restArgs);
     return;
   }
+  if (command === "ui") {
+    if (subcommand === "link") {
+      const component = toolArgs;
+      if (!component) {
+        console.error("Usage: lotics ui link <component> [--remove]");
+        console.error("Dev-links @lotics/ui to the monorepo's packages/ui/src for live HMR.");
+        process.exit(1);
+      }
+      appUiLink({ component, remove: restArgs.includes("--remove") });
+      return;
+    }
+    console.error(`Unknown ui subcommand: ${subcommand ?? "(none)"}`);
+    console.error("Usage: lotics ui link <component> [--remove]");
+    process.exit(1);
+  }
+  if (command === "app" && subcommand === "codegen") {
+    const projectDir = toolArgs;
+    const ctx2 = resolveContext(flags);
+    if (!ctx2) {
+      await appCodegen({ projectDir });
+      return;
+    }
+    const viewAsMemberId = flags.viewAs ?? process.env.LOTICS_VIEW_AS;
+    const client2 = new LoticsClient({ apiKey: ctx2.apiKey, workspaceId: ctx2.workspaceId, viewAsMemberId });
+    await resolveWorkspace(client2, ctx2);
+    await appCodegen({ projectDir, client: client2 });
+    return;
+  }
   if (command === "org") {
     const global2 = loadGlobalConfig() ?? {};
     const profiles = global2.profiles ?? {};
@@ -48408,6 +49432,10 @@ async function main() {
     console.error("  lotics app create <name> [path]      Scaffold a new app locally");
     console.error("  lotics app pull <app_id> [path]      Pull an existing app for local editing");
     console.error("  lotics app deploy [-m <message>]     Build + upload the current directory");
+    console.error("  lotics app codegen [path]            Regenerate .lotics/* (types + field ids) \u2014 no deploy");
+    console.error("  lotics app workflow run <alias> '<json>'  Execute a bound app workflow end-to-end");
+    console.error("  lotics app workflow set <alias>           Push the edited src/workflows/<alias>.ts body");
+    console.error("  lotics app workflow pull                  Rewrite src/workflows/*.ts from the server");
     console.error("  lotics app subdomain <new-subdomain> Rename the app's public <slug>.lotics.app address");
     console.error(`  lotics app rename "<new name>"        Rename the app's display name (launcher title)`);
     console.error("  lotics app dev [path]                Run the app locally with HMR + RPC forwarding");
@@ -48549,6 +49577,59 @@ Available workspaces:`);
       await appRename(client, { name: newName });
       return;
     }
+    if (subcommand === "workflow") {
+      const action = toolArgs;
+      const workflowUsage = () => {
+        console.error("Usage:");
+        console.error("  lotics app workflow run <alias> '<json>'   Execute a bound app workflow");
+        console.error("  lotics app workflow set <alias>            Push src/workflows/<alias>.ts");
+        console.error("  lotics app workflow pull                   Rewrite src/workflows/*.ts from the server");
+        process.exit(1);
+      };
+      if (action === "run") {
+        const alias = restArgs[0];
+        if (!alias) {
+          console.error("Usage: lotics app workflow run <alias> '<json>'");
+          console.error("       lotics app workflow run <alias> @inputs.json   (read inputs from a file)");
+          console.error("       cat inputs.json | lotics app workflow run <alias>   (read inputs from stdin)");
+          console.error("Flags: --print-created (report created records + cleanup plan + caveat)");
+          console.error("       --cleanup (also delete the created records \u2014 records only, NOT a rollback)");
+          process.exit(1);
+        }
+        const ingested = await ingestJsonArgs({
+          rawArg: restArgs[1],
+          stdinIsTTY: process.stdin.isTTY ?? false,
+          readFile: (p) => fs7.readFileSync(p, "utf-8"),
+          readStdin
+        });
+        if (ingested.kind === "error") {
+          console.error(ingested.message);
+          process.exit(1);
+        }
+        await appExecuteWorkflow(client, {
+          alias,
+          inputs: ingested.args,
+          printCreated: flags.printCreated,
+          cleanup: flags.cleanup
+        });
+        return;
+      }
+      if (action === "set") {
+        const alias = restArgs[0];
+        if (!alias) {
+          console.error("Usage: lotics app workflow set <alias>");
+          console.error("Pushes the edited src/workflows/<alias>.ts body via set_app_workflow.");
+          process.exit(1);
+        }
+        await appWorkflowSet(client, { alias });
+        return;
+      }
+      if (action === "pull") {
+        await appWorkflowPull(client);
+        return;
+      }
+      workflowUsage();
+    }
     if (subcommand === "dev") {
       const projectDir = toolArgs;
       let port;
@@ -48647,29 +49728,17 @@ ${JSON.stringify(info.input_schema, null, 2)}`);
   }
   if (command === "run") {
     const toolName = subcommand;
-    let rawArgs = toolArgs;
-    if (rawArgs && rawArgs.startsWith("@")) {
-      const argsPath = rawArgs.slice(1);
-      try {
-        rawArgs = fs7.readFileSync(argsPath, "utf-8");
-      } catch (err2) {
-        console.error(
-          `Cannot read args file "${argsPath}": ${err2 instanceof Error ? err2.message : String(err2)}`
-        );
-        process.exit(1);
-      }
-    } else if (!rawArgs && !process.stdin.isTTY) {
-      rawArgs = await readStdin();
-    }
-    let args = {};
-    if (rawArgs) {
-      try {
-        args = JSON.parse(rawArgs);
-      } catch {
-        console.error(`Invalid JSON: ${rawArgs}`);
-        process.exit(1);
-      }
+    const ingested = await ingestJsonArgs({
+      rawArg: toolArgs,
+      stdinIsTTY: process.stdin.isTTY ?? false,
+      readFile: (p) => fs7.readFileSync(p, "utf-8"),
+      readStdin
+    });
+    if (ingested.kind === "error") {
+      console.error(ingested.message);
+      process.exit(1);
     }
+    const args = ingested.args;
     const timeoutMs = flags.timeout ?? 6e4;
     const result = await client.execute(toolName, args, { format: "text", timeoutMs });
     if (result.error) {