@namzu/cli 35.0.0 → 36.1.0

package/dist/chunks/chunk-76FLAFCG.js

@@ -0,0 +1,51 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __name,
+  __require,
+  __commonJS,
+  __export,
+  __toESM
+};
+//# sourceMappingURL=chunk-76FLAFCG.js.map

package/dist/chunks/chunk-76FLAFCG.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": [],
+  "mappings": "",
+  "names": []
+}

package/dist/chunks/chunk-7WJOQ6EA.js

@@ -0,0 +1,106 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  TERMINATION_SIGNALS,
+  setTerminating,
+  terminationInProgress
+} from "./chunk-TBIX6JRE.js";
+import {
+  releaseHeldSessionLeases
+} from "./chunk-EWKJGHRO.js";
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// src/termination.ts
+import { constants } from "node:os";
+var LEASE_RELEASE_MS = 2e3;
+var CLEANUP_MS = 6e3;
+var RERAISE_GRACE_MS = 1e3;
+function bounded(work, ms) {
+  let timer;
+  return Promise.race([
+    work.then(
+      () => void 0,
+      () => void 0
+    ),
+    new Promise((resolve) => {
+      timer = setTimeout(resolve, ms);
+    })
+  ]).finally(() => clearTimeout(timer));
+}
+__name(bounded, "bounded");
+function signalExitCode(signal) {
+  return 128 + (constants.signals[signal] ?? 15);
+}
+__name(signalExitCode, "signalExitCode");
+function handleTerminationSignals(options = {}) {
+  const proc = options.process ?? process;
+  const cleanups = [];
+  let disposed = false;
+  const detach = /* @__PURE__ */ __name(() => {
+    for (const signal of TERMINATION_SIGNALS) proc.removeListener(signal, listeners[signal]);
+  }, "detach");
+  const finish = /* @__PURE__ */ __name((signal) => {
+    detach();
+    if (options.onFinished) {
+      options.onFinished(signal);
+      return;
+    }
+    if (proc.platform === "win32") proc.exit(signalExitCode(signal));
+    setTimeout(() => proc.exit(signalExitCode(signal)), RERAISE_GRACE_MS);
+    proc.kill(proc.pid, signal);
+  }, "finish");
+  const handle = /* @__PURE__ */ __name(async (signal) => {
+    if (terminationInProgress() !== null) {
+      proc.exit(signalExitCode(signal));
+      return;
+    }
+    setTerminating(signal);
+    await releaseHeldSessionLeases({ timeoutMs: options.leaseReleaseMs ?? LEASE_RELEASE_MS });
+    await bounded(
+      (async () => {
+        for (const cleanup of cleanups) {
+          try {
+            await cleanup(signal);
+          } catch {
+          }
+        }
+      })(),
+      options.cleanupMs ?? CLEANUP_MS
+    );
+    finish(signal);
+  }, "handle");
+  const listeners = Object.fromEntries(
+    TERMINATION_SIGNALS.map((signal) => [signal, () => void handle(signal)])
+  );
+  for (const signal of TERMINATION_SIGNALS) proc.on(signal, listeners[signal]);
+  return {
+    onTerminate(cleanup) {
+      cleanups.push(cleanup);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (terminationInProgress() === null) detach();
+    }
+  };
+}
+__name(handleTerminationSignals, "handleTerminationSignals");
+function withTerminationHandling(handler) {
+  return async (args) => {
+    const termination = handleTerminationSignals();
+    try {
+      return await handler(args, termination);
+    } finally {
+      termination.dispose();
+    }
+  };
+}
+__name(withTerminationHandling, "withTerminationHandling");
+
+export {
+  handleTerminationSignals,
+  withTerminationHandling
+};
+//# sourceMappingURL=chunk-7WJOQ6EA.js.map

package/dist/chunks/chunk-7WJOQ6EA.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/termination.ts"],
+  "mappings": ";;;;;;;;;;;;;;;AA8BA,SAAS,iBAAiB;AAc1B,IAAM,mBAAmB;AAEzB,IAAM,aAAa;AAEnB,IAAM,mBAAmB;AA2BzB,SAAS,QAAQ,MAAwB,IAA2B;AACnE,MAAI;AACJ,SAAO,QAAQ,KAAK;AAAA,IACnB,KAAK;AAAA,MACJ,MAAM;AAAA,MACN,MAAM;AAAA,IACP;AAAA,IACA,IAAI,QAAc,CAAC,YAAY;AAC9B,cAAQ,WAAW,SAAS,EAAE;AAAA,IAC/B,CAAC;AAAA,EACF,CAAC,EAAE,QAAQ,MAAM,aAAa,KAAK,CAAC;AACrC;AAXS;AAcF,SAAS,eAAe,QAAmC;AACjE,SAAO,OAAO,UAAU,QAAQ,MAAM,KAAK;AAC5C;AAFgB;AAQT,SAAS,yBACf,UAAoC,CAAC,GACf;AACtB,QAAM,OAA2B,QAAQ,WAAY;AACrD,QAAM,WAAuE,CAAC;AAC9E,MAAI,WAAW;AAEf,QAAM,SAAS,6BAAY;AAC1B,eAAW,UAAU,oBAAqB,MAAK,eAAe,QAAQ,UAAU,MAAM,CAAC;AAAA,EACxF,GAFe;AAIf,QAAM,SAAS,wBAAC,WAAoC;AACnD,WAAO;AACP,QAAI,QAAQ,YAAY;AACvB,cAAQ,WAAW,MAAM;AACzB;AAAA,IACD;AAGA,QAAI,KAAK,aAAa,QAAS,MAAK,KAAK,eAAe,MAAM,CAAC;AAC/D,eAAW,MAAM,KAAK,KAAK,eAAe,MAAM,CAAC,GAAG,gBAAgB;AACpE,SAAK,KAAK,KAAK,KAAK,MAAM;AAAA,EAC3B,GAXe;AAaf,QAAM,SAAS,8BAAO,WAA6C;AAClE,QAAI,sBAAsB,MAAM,MAAM;AAErC,WAAK,KAAK,eAAe,MAAM,CAAC;AAChC;AAAA,IACD;AACA,mBAAe,MAAM;AACrB,UAAM,yBAAyB,EAAE,WAAW,QAAQ,kBAAkB,iBAAiB,CAAC;AACxF,UAAM;AAAA,OACJ,YAAY;AACZ,mBAAW,WAAW,UAAU;AAC/B,cAAI;AACH,kBAAM,QAAQ,MAAM;AAAA,UACrB,QAAQ;AAAA,UAER;AAAA,QACD;AAAA,MACD,GAAG;AAAA,MACH,QAAQ,aAAa;AAAA,IACtB;AACA,WAAO,MAAM;AAAA,EACd,GArBe;AAuBf,QAAM,YAAY,OAAO;AAAA,IACxB,oBAAoB,IAAI,CAAC,WAAW,CAAC,QAAQ,MAAM,KAAK,OAAO,MAAM,CAAC,CAAC;AAAA,EACxE;AACA,aAAW,UAAU,oBAAqB,MAAK,GAAG,QAAQ,UAAU,MAAM,CAAC;AAE3E,SAAO;AAAA,IACN,YAAY,SAAS;AACpB,eAAS,KAAK,OAAO;AAAA,IACtB;AAAA,IACA,UAAU;AACT,UAAI,SAAU;AACd,iBAAW;AAEX,UAAI,sBAAsB,MAAM,KAAM,QAAO;AAAA,IAC9C;AAAA,EACD;AACD;AA/DgB;AAqET,SAAS,wBACf,SAC+B;AAC/B,SAAO,OAAO,SAAS;AACtB,UAAM,cAAc,yBAAyB;AAC7C,QAAI;AACH,aAAO,MAAM,QAAQ,MAAM,WAAW;AAAA,IACvC,UAAE;AACD,kBAAY,QAAQ;AAAA,IACrB;AAAA,EACD;AACD;AAXgB;",
+  "names": []
+}

package/dist/chunks/chunk-A22MBIYU.js

@@ -0,0 +1,42 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// src/schedule/paths.ts
+import { join } from "node:path";
+function schedulePaths(home) {
+  const root = join(home, "schedule");
+  const daemon = join(root, "daemon");
+  return {
+    home,
+    root,
+    jobs: join(root, "jobs"),
+    state: join(root, "state"),
+    claims: join(root, "claims"),
+    history: join(root, "history"),
+    runs: join(root, "runs"),
+    daemon,
+    daemonLog: join(daemon, "log"),
+    endpoint: join(daemon, "endpoint.json"),
+    heartbeat: join(daemon, "heartbeat.json"),
+    service: join(root, "service.json"),
+    seen: join(root, "seen.json"),
+    daemonEnv: join(root, "daemon.env"),
+    job: /* @__PURE__ */ __name((id) => join(root, "jobs", `${id}.json`), "job"),
+    stateOf: /* @__PURE__ */ __name((id) => join(root, "state", `${id}.json`), "stateOf"),
+    claimsOf: /* @__PURE__ */ __name((id) => join(root, "claims", id), "claimsOf"),
+    claim: /* @__PURE__ */ __name((id, key) => join(root, "claims", id, `${key}.json`), "claim"),
+    historyOf: /* @__PURE__ */ __name((id) => join(root, "history", `${id}.jsonl`), "historyOf"),
+    runsOf: /* @__PURE__ */ __name((id) => join(root, "runs", id), "runsOf"),
+    runResult: /* @__PURE__ */ __name((id, runId) => join(root, "runs", id, `${runId}.json`), "runResult"),
+    runLog: /* @__PURE__ */ __name((id, runId) => join(root, "runs", id, `${runId}.log`), "runLog")
+  };
+}
+__name(schedulePaths, "schedulePaths");
+
+export {
+  schedulePaths
+};
+//# sourceMappingURL=chunk-A22MBIYU.js.map

package/dist/chunks/chunk-A22MBIYU.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/schedule/paths.ts"],
+  "mappings": ";;;;;;;AAwBA,SAAS,YAAY;AA2Bd,SAAS,cAAc,MAA6B;AAC1D,QAAM,OAAO,KAAK,MAAM,UAAU;AAClC,QAAM,SAAS,KAAK,MAAM,QAAQ;AAClC,SAAO;AAAA,IACN;AAAA,IACA;AAAA,IACA,MAAM,KAAK,MAAM,MAAM;AAAA,IACvB,OAAO,KAAK,MAAM,OAAO;AAAA,IACzB,QAAQ,KAAK,MAAM,QAAQ;AAAA,IAC3B,SAAS,KAAK,MAAM,SAAS;AAAA,IAC7B,MAAM,KAAK,MAAM,MAAM;AAAA,IACvB;AAAA,IACA,WAAW,KAAK,QAAQ,KAAK;AAAA,IAC7B,UAAU,KAAK,QAAQ,eAAe;AAAA,IACtC,WAAW,KAAK,QAAQ,gBAAgB;AAAA,IACxC,SAAS,KAAK,MAAM,cAAc;AAAA,IAClC,MAAM,KAAK,MAAM,WAAW;AAAA,IAC5B,WAAW,KAAK,MAAM,YAAY;AAAA,IAClC,KAAK,wBAAC,OAAO,KAAK,MAAM,QAAQ,GAAG,EAAE,OAAO,GAAvC;AAAA,IACL,SAAS,wBAAC,OAAO,KAAK,MAAM,SAAS,GAAG,EAAE,OAAO,GAAxC;AAAA,IACT,UAAU,wBAAC,OAAO,KAAK,MAAM,UAAU,EAAE,GAA/B;AAAA,IACV,OAAO,wBAAC,IAAI,QAAQ,KAAK,MAAM,UAAU,IAAI,GAAG,GAAG,OAAO,GAAnD;AAAA,IACP,WAAW,wBAAC,OAAO,KAAK,MAAM,WAAW,GAAG,EAAE,QAAQ,GAA3C;AAAA,IACX,QAAQ,wBAAC,OAAO,KAAK,MAAM,QAAQ,EAAE,GAA7B;AAAA,IACR,WAAW,wBAAC,IAAI,UAAU,KAAK,MAAM,QAAQ,IAAI,GAAG,KAAK,OAAO,GAArD;AAAA,IACX,QAAQ,wBAAC,IAAI,UAAU,KAAK,MAAM,QAAQ,IAAI,GAAG,KAAK,MAAM,GAApD;AAAA,EACT;AACD;AA3BgB;",
+  "names": []
+}

package/dist/chunks/chunk-A5DWGNGR.js

@@ -0,0 +1,73 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  getCliPalRuntime
+} from "./chunk-2NJ2XUXJ.js";
+import {
+  palSessionEnvironment
+} from "./chunk-UXVYJWN5.js";
+import {
+  palConversationBinding
+} from "./chunk-AIY4PCDR.js";
+import {
+  PROVIDER_REGISTRY
+} from "./chunk-6LLJQ3KY.js";
+import {
+  palAtWorkspace
+} from "./chunk-OLPOM3DR.js";
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// src/pals/tui-session.ts
+function tuiPalOwner(cwd, expectedId) {
+  const pal = palAtWorkspace(cwd);
+  if (expectedId && pal?.id !== expectedId)
+    throw new Error("This workspace does not belong to the requested Pal.");
+  return pal;
+}
+__name(tuiPalOwner, "tuiPalOwner");
+async function tuiPalDefinition(cwd, sessionId, expectedId) {
+  const owner = tuiPalOwner(cwd, expectedId);
+  if (!owner) return null;
+  const binding = await palConversationBinding(cwd, sessionId);
+  if (!binding || binding.pal.id !== owner.id)
+    throw new Error("This conversation does not belong to this Pal.");
+  if (binding.pal.paused) throw new Error("This Pal is paused. Resume it before starting work.");
+  return binding.definition;
+}
+__name(tuiPalDefinition, "tuiPalDefinition");
+function tuiPalPreferences(definition, fallback) {
+  if (!definition.model) return fallback;
+  const { provider, model } = definition.model;
+  if (!Object.hasOwn(PROVIDER_REGISTRY, provider))
+    throw new Error("The Pal model provider is unavailable in this CLI.");
+  return {
+    version: 3,
+    providers: [{ id: provider, model }],
+    subagents: { active: [] }
+  };
+}
+__name(tuiPalPreferences, "tuiPalPreferences");
+async function tuiPalEnvironment(definition, sessionId, signal) {
+  const runtime = await getCliPalRuntime();
+  signal?.throwIfAborted();
+  return palSessionEnvironment(runtime, definition, sessionId);
+}
+__name(tuiPalEnvironment, "tuiPalEnvironment");
+async function tuiPalWorkEnvironment(definition, sessionId, signal) {
+  const runtime = await getCliPalRuntime();
+  const lease = await runtime.startComputer(definition.id, signal);
+  const binding = palSessionEnvironment(runtime, definition, sessionId);
+  return { definition: binding.definition, lease, admit: binding.admit };
+}
+__name(tuiPalWorkEnvironment, "tuiPalWorkEnvironment");
+
+export {
+  tuiPalOwner,
+  tuiPalDefinition,
+  tuiPalPreferences,
+  tuiPalEnvironment,
+  tuiPalWorkEnvironment
+};
+//# sourceMappingURL=chunk-A5DWGNGR.js.map

package/dist/chunks/chunk-A5DWGNGR.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/pals/tui-session.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAQO,SAAS,YAAY,KAAa,YAAiC;AACzE,QAAM,MAAM,eAAe,GAAG;AAC9B,MAAI,cAAc,KAAK,OAAO;AAC7B,UAAM,IAAI,MAAM,sDAAsD;AACvE,SAAO;AACR;AALgB;AAOhB,eAAsB,iBACrB,KACA,WACA,YACsB;AACtB,QAAM,QAAQ,YAAY,KAAK,UAAU;AACzC,MAAI,CAAC,MAAO,QAAO;AACnB,QAAM,UAAU,MAAM,uBAAuB,KAAK,SAAS;AAC3D,MAAI,CAAC,WAAW,QAAQ,IAAI,OAAO,MAAM;AACxC,UAAM,IAAI,MAAM,gDAAgD;AACjE,MAAI,QAAQ,IAAI,OAAQ,OAAM,IAAI,MAAM,qDAAqD;AAC7F,SAAO,QAAQ;AAChB;AAZsB;AAcf,SAAS,kBACf,YACA,UACqB;AACrB,MAAI,CAAC,WAAW,MAAO,QAAO;AAC9B,QAAM,EAAE,UAAU,MAAM,IAAI,WAAW;AACvC,MAAI,CAAC,OAAO,OAAO,mBAAmB,QAAQ;AAC7C,UAAM,IAAI,MAAM,oDAAoD;AACrE,SAAO;AAAA,IACN,SAAS;AAAA,IACT,WAAW,CAAC,EAAE,IAAI,UAAwB,MAAM,CAAC;AAAA,IACjD,WAAW,EAAE,QAAQ,CAAC,EAAE;AAAA,EACzB;AACD;AAbgB;AAehB,eAAsB,kBACrB,YACA,WACA,QACiC;AACjC,QAAM,UAAU,MAAM,iBAAiB;AACvC,UAAQ,eAAe;AACvB,SAAO,sBAAsB,SAAS,YAAY,SAAS;AAC5D;AARsB;AAWtB,eAAsB,sBACrB,YACA,WACA,QACiC;AACjC,QAAM,UAAU,MAAM,iBAAiB;AACvC,QAAM,QAAQ,MAAM,QAAQ,cAAc,WAAW,IAAI,MAAM;AAC/D,QAAM,UAAU,sBAAsB,SAAS,YAAY,SAAS;AACpE,SAAO,EAAE,YAAY,QAAQ,YAAY,OAAO,OAAO,QAAQ,MAAM;AACtE;AATsB;",
+  "names": []
+}

package/dist/chunks/chunk-A5UXODFL.js

@@ -0,0 +1,76 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  restrictToOwner,
+  restrictToOwnerOnce
+} from "./chunk-Q24K7536.js";
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// src/integrations/state/private-directory.ts
+import { chmodSync, lstatSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+var PRIVATE_DIRECTORY_MODE = 448;
+function ensurePrivateStateDirectory(stateRoot, segment) {
+  if (!/^[A-Za-z0-9_-]+$/u.test(segment)) {
+    throw new Error(`Namzu state partition must be one safe path segment: ${segment}`);
+  }
+  mkdirSync(stateRoot, { recursive: true });
+  const rootEntry = lstatSync(stateRoot);
+  if (rootEntry.isSymbolicLink() || !rootEntry.isDirectory()) {
+    throw new Error(`Namzu state root must be a real directory: ${stateRoot}`);
+  }
+  const path = join(stateRoot, segment);
+  mkdirSync(path, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+  const entry = lstatSync(path);
+  if (entry.isSymbolicLink() || !entry.isDirectory()) {
+    throw new Error(`Namzu state partition must be a real directory: ${path}`);
+  }
+  if (process.platform !== "win32") chmodSync(path, PRIVATE_DIRECTORY_MODE);
+  restrictToOwnerOnce(path);
+  return path;
+}
+__name(ensurePrivateStateDirectory, "ensurePrivateStateDirectory");
+
+// src/integrations/state/immutable-json.ts
+import { randomUUID } from "node:crypto";
+import {
+  closeSync,
+  fsyncSync,
+  linkSync,
+  mkdirSync as mkdirSync2,
+  openSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { dirname } from "node:path";
+function publishPrivateJsonIfAbsent(path, value) {
+  mkdirSync2(dirname(path), { recursive: true, mode: 448 });
+  const candidate = `${path}.candidate.${randomUUID()}`;
+  const descriptor = openSync(candidate, "wx", 384);
+  try {
+    try {
+      writeFileSync(descriptor, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+      fsyncSync(descriptor);
+    } finally {
+      closeSync(descriptor);
+    }
+    restrictToOwner(candidate);
+    try {
+      linkSync(candidate, path);
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+  } finally {
+    unlinkSync(candidate);
+  }
+}
+__name(publishPrivateJsonIfAbsent, "publishPrivateJsonIfAbsent");
+
+export {
+  ensurePrivateStateDirectory,
+  publishPrivateJsonIfAbsent
+};
+//# sourceMappingURL=chunk-A5UXODFL.js.map

package/dist/chunks/chunk-A5UXODFL.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/integrations/state/private-directory.ts", "../../src/integrations/state/immutable-json.ts"],
+  "mappings": ";;;;;;;;;;;AAAA,SAAS,WAAW,WAAW,iBAAiB;AAChD,SAAS,YAAY;AAIrB,IAAM,yBAAyB;AAiBxB,SAAS,4BAA4B,WAAmB,SAAyB;AACvF,MAAI,CAAC,oBAAoB,KAAK,OAAO,GAAG;AACvC,UAAM,IAAI,MAAM,wDAAwD,OAAO,EAAE;AAAA,EAClF;AACA,YAAU,WAAW,EAAE,WAAW,KAAK,CAAC;AACxC,QAAM,YAAY,UAAU,SAAS;AACrC,MAAI,UAAU,eAAe,KAAK,CAAC,UAAU,YAAY,GAAG;AAC3D,UAAM,IAAI,MAAM,8CAA8C,SAAS,EAAE;AAAA,EAC1E;AAEA,QAAM,OAAO,KAAK,WAAW,OAAO;AACpC,YAAU,MAAM,EAAE,WAAW,MAAM,MAAM,uBAAuB,CAAC;AACjE,QAAM,QAAQ,UAAU,IAAI;AAC5B,MAAI,MAAM,eAAe,KAAK,CAAC,MAAM,YAAY,GAAG;AACnD,UAAM,IAAI,MAAM,mDAAmD,IAAI,EAAE;AAAA,EAC1E;AACA,MAAI,QAAQ,aAAa,QAAS,WAAU,MAAM,sBAAsB;AAIxE,sBAAoB,IAAI;AACxB,SAAO;AACR;AAtBgB;;;ACtBhB,SAAS,kBAAkB;AAC3B;AAAA,EACC;AAAA,EACA;AAAA,EACA;AAAA,EACA,aAAAA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACM;AACP,SAAS,eAAe;AAYjB,SAAS,2BAA2B,MAAc,OAAsB;AAC9E,EAAAC,WAAU,QAAQ,IAAI,GAAG,EAAE,WAAW,MAAM,MAAM,IAAM,CAAC;AACzD,QAAM,YAAY,GAAG,IAAI,cAAc,WAAW,CAAC;AACnD,QAAM,aAAa,SAAS,WAAW,MAAM,GAAK;AAClD,MAAI;AACH,QAAI;AACH,oBAAc,YAAY,GAAG,KAAK,UAAU,OAAO,MAAM,CAAC,CAAC;AAAA,GAAM,MAAM;AACvE,gBAAU,UAAU;AAAA,IACrB,UAAE;AACD,gBAAU,UAAU;AAAA,IACrB;AACA,oBAAgB,SAAS;AACzB,QAAI;AACH,eAAS,WAAW,IAAI;AAAA,IACzB,SAAS,OAAO;AACf,UAAK,MAAgC,SAAS,SAAU,OAAM;AAAA,IAC/D;AAAA,EACD,UAAE;AACD,eAAW,SAAS;AAAA,EACrB;AACD;AApBgB;",
+  "names": ["mkdirSync", "mkdirSync"]
+}