@vimhead.dev/norn-cli 0.1.0-tip.35614826665.1 → 0.1.0-tip.35724621678.1

package/dist/internal/file-coordinator.js

@@ -30,22 +30,38 @@ async function writeTextAtomically(path, content) {
 
 // src/internal/file-coordinator.ts
 import { createHash, randomUUID as randomUUID2 } from "node:crypto";
-import { lstat, mkdir as mkdir2, mkdtemp, readFile, readdir, realpath, rename as rename2, rm as rm2, rmdir, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import {
+  lstat,
+  mkdir as mkdir2,
+  mkdtemp,
+  readFile,
+  readdir,
+  realpath,
+  rename as rename2,
+  rm as rm2,
+  rmdir,
+  unlink,
+  writeFile as writeFile2
+} from "node:fs/promises";
 import { hostname } from "node:os";
 import { basename, dirname as dirname2, join, resolve } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
-var ownerSchema = Type.Object({
-  token: Type.String({ format: "uuid" }),
-  pid: Type.Integer({ exclusiveMinimum: 0 }),
-  host: Type.String(),
-  target: Type.String()
-}, { additionalProperties: false });
+var ownerSchema = Type.Object(
+  {
+    token: Type.String({ format: "uuid" }),
+    pid: Type.Integer({ exclusiveMinimum: 0 }),
+    host: Type.String(),
+    target: Type.String()
+  },
+  { additionalProperties: false }
+);
 var NornFileCoordinator = class {
   constructor(input) {
     this.input = input;
-    if (!Number.isSafeInteger(input.waitTimeoutMs) || input.waitTimeoutMs <= 0) throw new Error("Lock wait timeout must be a positive integer");
+    if (!Number.isSafeInteger(input.waitTimeoutMs) || input.waitTimeoutMs <= 0)
+      throw new Error("Lock wait timeout must be a positive integer");
     this.lockRoot = resolve(input.lockRoot);
   }
   input;
@@ -60,7 +76,11 @@ var NornFileCoordinator = class {
     const marker = `${token}.json`;
     return this.withCleanup({
       operation: async () => {
-        await writeFile2(join(stagingPath, marker), JSON.stringify({ token, pid: process.pid, host: hostname(), target }), { mode: 384 });
+        await writeFile2(
+          join(stagingPath, marker),
+          JSON.stringify({ token, pid: process.pid, host: hostname(), target }),
+          { mode: 384 }
+        );
         await this.acquire({ stagingPath, lockPath, target });
         return this.withCleanup({
           operation: () => operation(target),
@@ -74,11 +94,17 @@ var NornFileCoordinator = class {
     });
   }
   async readText(path) {
-    return this.withExclusiveLock(path, (lockedPath) => readFile(lockedPath, "utf8"));
+    return this.withExclusiveLock(
+      path,
+      (lockedPath) => readFile(lockedPath, "utf8")
+    );
   }
   async writeText(path, content) {
     await mkdir2(dirname2(path), { recursive: true });
-    await this.withExclusiveLock(path, (lockedPath) => writeTextAtomically(lockedPath, content));
+    await this.withExclusiveLock(
+      path,
+      (lockedPath) => writeTextAtomically(lockedPath, content)
+    );
   }
   async withCleanup(input) {
     let result;
@@ -88,7 +114,10 @@ var NornFileCoordinator = class {
       try {
         await input.cleanup();
       } catch (cleanupError) {
-        throw new AggregateError([error, cleanupError], "File operation and lock cleanup failed");
+        throw new AggregateError(
+          [error, cleanupError],
+          "File operation and lock cleanup failed"
+        );
       }
       throw error;
     }
@@ -104,7 +133,8 @@ var NornFileCoordinator = class {
         if (isNodeError(error2) && error2.code === "ENOENT") return void 0;
         throw error2;
       });
-      if (entry?.isSymbolicLink()) throw new Error(`Cannot lock a dangling symbolic link: ${path}`);
+      if (entry?.isSymbolicLink())
+        throw new Error(`Cannot lock a dangling symbolic link: ${path}`);
       return join(await realpath(dirname2(path)), basename(path));
     }
   }
@@ -115,10 +145,12 @@ var NornFileCoordinator = class {
         await rename2(input.stagingPath, input.lockPath);
         return;
       } catch (error) {
-        if (!isNodeError(error) || !["ENOTEMPTY", "EEXIST"].includes(error.code ?? "")) throw error;
+        if (!isNodeError(error) || !["ENOTEMPTY", "EEXIST"].includes(error.code ?? ""))
+          throw error;
       }
       await this.reclaimDeadOwner(input);
-      if (Date.now() >= deadline) throw new Error(`Timed out waiting for file lock: ${input.target}`);
+      if (Date.now() >= deadline)
+        throw new Error(`Timed out waiting for file lock: ${input.target}`);
       await delay(10);
     }
   }
@@ -126,9 +158,13 @@ var NornFileCoordinator = class {
     try {
       const entries = await readdir(input.lockPath);
       if (entries.length === 0) return;
-      if (entries.length !== 1) throw new Error(`Invalid file lock ownership: ${input.lockPath}`);
+      if (entries.length !== 1)
+        throw new Error(`Invalid file lock ownership: ${input.lockPath}`);
       const marker = entries[0];
-      const owner = Value.Parse(ownerSchema, JSON.parse(await readFile(join(input.lockPath, marker), "utf8")));
+      const owner = Value.Parse(
+        ownerSchema,
+        JSON.parse(await readFile(join(input.lockPath, marker), "utf8"))
+      );
       if (marker !== `${owner.token}.json` || owner.target !== input.target || owner.host !== hostname()) {
         throw new Error(`Incompatible file lock ownership: ${input.lockPath}`);
       }
@@ -149,12 +185,16 @@ var NornFileCoordinator = class {
     try {
       await rmdir(path);
     } catch (error) {
-      if (!isNodeError(error) || !["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code ?? "")) throw error;
+      if (!isNodeError(error) || !["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code ?? ""))
+        throw error;
     }
   }
 };
 function createRunFileCoordinator(runRoot) {
-  return new NornFileCoordinator({ lockRoot: join(runRoot, "locks"), waitTimeoutMs: 3e4 });
+  return new NornFileCoordinator({
+    lockRoot: join(runRoot, "locks"),
+    waitTimeoutMs: 3e4
+  });
 }
 export {
   NornFileCoordinator,

package/dist/internal/launch-request.js

@@ -45,7 +45,9 @@ async function writeRunLaunchRequest(runRoot, request) {
   await writeJsonAtomically(join(runRoot, LAUNCH_REQUEST_FILE_NAME), request);
 }
 async function readRunLaunchRequest(runRoot) {
-  return parseRunLaunchRequest(JSON.parse(await readFile(join(runRoot, LAUNCH_REQUEST_FILE_NAME), "utf8")));
+  return parseRunLaunchRequest(
+    JSON.parse(await readFile(join(runRoot, LAUNCH_REQUEST_FILE_NAME), "utf8"))
+  );
 }
 async function writeRunResumeRequest(runRoot, request) {
   const path = join(runRoot, RESUME_REQUEST_FILE_NAME);
@@ -58,7 +60,9 @@ async function writeRunResumeRequest(runRoot, request) {
   }
 }
 async function readRunResumeRequest(runRoot) {
-  return parseRunResumeRequest(JSON.parse(await readFile(join(runRoot, RESUME_REQUEST_FILE_NAME), "utf8")));
+  return parseRunResumeRequest(
+    JSON.parse(await readFile(join(runRoot, RESUME_REQUEST_FILE_NAME), "utf8"))
+  );
 }
 async function readOptionalRunResumeRequest(runRoot) {
   try {
@@ -73,27 +77,41 @@ function matchesRunResumeRequest(actual, expected) {
 }
 async function clearRunResumeRequest(input) {
   await input.lease.assertOwned();
-  if (matchesRunResumeRequest(await readOptionalRunResumeRequest(input.runRoot), input.request)) {
+  if (matchesRunResumeRequest(
+    await readOptionalRunResumeRequest(input.runRoot),
+    input.request
+  )) {
     await rm2(join(input.runRoot, RESUME_REQUEST_FILE_NAME), { force: true });
   }
 }
 function parseRunLaunchRequest(value) {
-  if (!value || typeof value !== "object") throw new Error("Invalid workflow launch request");
+  if (!value || typeof value !== "object")
+    throw new Error("Invalid workflow launch request");
   const request = value;
-  if (request.version !== 2 || request.type !== "run") throw new Error("Unsupported workflow launch request");
-  if (typeof request.id !== "string" || request.id.length === 0) throw new Error("Invalid workflow launch request id");
-  if (typeof request.name !== "string" || request.name.length === 0) throw new Error("Invalid workflow launch request name");
-  if (typeof request.workflowId !== "string" || request.workflowId.length === 0) throw new Error("Invalid workflow launch request workflow id");
-  if (typeof request.createdAt !== "string" || Number.isNaN(Date.parse(request.createdAt))) throw new Error("Invalid workflow launch request timestamp");
+  if (request.version !== 2 || request.type !== "run")
+    throw new Error("Unsupported workflow launch request");
+  if (typeof request.id !== "string" || request.id.length === 0)
+    throw new Error("Invalid workflow launch request id");
+  if (typeof request.name !== "string" || request.name.length === 0)
+    throw new Error("Invalid workflow launch request name");
+  if (typeof request.workflowId !== "string" || request.workflowId.length === 0)
+    throw new Error("Invalid workflow launch request workflow id");
+  if (typeof request.createdAt !== "string" || Number.isNaN(Date.parse(request.createdAt)))
+    throw new Error("Invalid workflow launch request timestamp");
   return request;
 }
 function parseRunResumeRequest(value) {
-  if (!value || typeof value !== "object") throw new Error("Invalid workflow resume request");
+  if (!value || typeof value !== "object")
+    throw new Error("Invalid workflow resume request");
   const request = value;
-  if (request.version !== 2 || request.type !== "resume") throw new Error("Unsupported workflow resume request");
-  if (typeof request.id !== "string" || request.id.length === 0) throw new Error("Invalid workflow resume request id");
-  if (request.requestId !== void 0 && (typeof request.requestId !== "string" || request.requestId.length === 0)) throw new Error("Invalid workflow resume request token");
-  if (typeof request.createdAt !== "string" || Number.isNaN(Date.parse(request.createdAt))) throw new Error("Invalid workflow resume request timestamp");
+  if (request.version !== 2 || request.type !== "resume")
+    throw new Error("Unsupported workflow resume request");
+  if (typeof request.id !== "string" || request.id.length === 0)
+    throw new Error("Invalid workflow resume request id");
+  if (request.requestId !== void 0 && (typeof request.requestId !== "string" || request.requestId.length === 0))
+    throw new Error("Invalid workflow resume request token");
+  if (typeof request.createdAt !== "string" || Number.isNaN(Date.parse(request.createdAt)))
+    throw new Error("Invalid workflow resume request timestamp");
   return request;
 }
 export {

package/dist/internal/metrics.js

@@ -10,7 +10,11 @@ function isNodeError(error) {
 }
 
 // src/internal/metrics.ts
-import { addAgentUsage, agentUsageFromValue, emptyAgentUsage } from "./usage.js";
+import {
+  addAgentUsage,
+  agentUsageFromValue,
+  emptyAgentUsage
+} from "./usage.js";
 var LEGACY_RUN_STATE_FILE_NAME = "runtime-state.json";
 async function readRunMetrics(runRoot) {
   const currentRoot = runCurrentRoot(runRoot);
@@ -32,7 +36,8 @@ function calculateRunMetrics(events, state, now) {
   let agentUsage = emptyAgentUsage();
   for (const event of events) {
     const eventAtMs = timestampMs(event.at);
-    if (event.type === "run.interrupted" && eventAtMs !== void 0) gateStartedAtMs = eventAtMs;
+    if (event.type === "run.interrupted" && eventAtMs !== void 0)
+      gateStartedAtMs = eventAtMs;
     else if (event.type === "run.resumed" && eventAtMs !== void 0 && gateStartedAtMs !== void 0) {
       gateWaitMs += Math.max(0, eventAtMs - gateStartedAtMs);
       gateStartedAtMs = void 0;
@@ -50,40 +55,87 @@ function calculateRunMetrics(events, state, now) {
       continue;
     }
     if (event.type === "agent.started") {
-      if (openWorkflow) openWorkflow = startAgentMetrics(openWorkflow, event, now);
+      if (openWorkflow)
+        openWorkflow = startAgentMetrics(openWorkflow, event, now);
       continue;
     }
     if (event.type === "agent.completed" || event.type === "agent.failed") {
       const usage = agentUsageFromEvent(event);
       agentUsage = addAgentUsage(agentUsage, usage);
-      if (openWorkflow) openWorkflow = finishAgentMetrics(openWorkflow, event, usage, now);
+      if (openWorkflow)
+        openWorkflow = finishAgentMetrics(openWorkflow, event, usage, now);
       continue;
     }
     if (event.type === "command.started") {
-      if (openWorkflow) openWorkflow = startCommandMetrics(openWorkflow, event, now);
+      if (openWorkflow)
+        openWorkflow = startCommandMetrics(openWorkflow, event, now);
       continue;
     }
     if (event.type === "command.completed" || event.type === "command.failed") {
-      if (openWorkflow) openWorkflow = finishCommandMetrics(openWorkflow, event, now);
+      if (openWorkflow)
+        openWorkflow = finishCommandMetrics(openWorkflow, event, now);
       continue;
     }
     const status = workflowTerminalStatus(event.type);
     if (status) {
       const durationMs = numberField(event.durationMs) || (openWorkflow && eventAtMs !== void 0 ? Math.max(0, eventAtMs - openWorkflow.startedAtMs) : 0);
-      const workflowId = status === "transitioned" ? stringField(event.fromWorkflowId, openWorkflow?.workflowId ?? "unknown") : stringField(event.workflowId, openWorkflow?.workflowId ?? "unknown");
-      const workflow = openWorkflow ?? createSyntheticWorkflowMetrics(workflowId, startedAtMs, endedAtMs, eventAtMs, durationMs);
+      const workflowId = status === "transitioned" ? stringField(
+        event.fromWorkflowId,
+        openWorkflow?.workflowId ?? "unknown"
+      ) : stringField(
+        event.workflowId,
+        openWorkflow?.workflowId ?? "unknown"
+      );
+      const workflow = openWorkflow ?? createSyntheticWorkflowMetrics(
+        workflowId,
+        startedAtMs,
+        endedAtMs,
+        eventAtMs,
+        durationMs
+      );
       const childStatus = status === "failed" ? "failed" : "completed";
-      workflows.push(closeWorkflowMetrics(closeOpenChildMetrics(workflow, eventAtMs ?? now.getTime(), event.at, childStatus), workflows.length + 1, status, durationMs, event.at));
+      workflows.push(
+        closeWorkflowMetrics(
+          closeOpenChildMetrics(
+            workflow,
+            eventAtMs ?? now.getTime(),
+            event.at,
+            childStatus
+          ),
+          workflows.length + 1,
+          status,
+          durationMs,
+          event.at
+        )
+      );
       openWorkflow = void 0;
     }
   }
-  if (gateStartedAtMs !== void 0) gateWaitMs += Math.max(0, endedAtMs - gateStartedAtMs);
+  if (gateStartedAtMs !== void 0)
+    gateWaitMs += Math.max(0, endedAtMs - gateStartedAtMs);
   if (openWorkflow) {
-    workflows.push(closeWorkflowMetrics(closeOpenChildMetrics(openWorkflow, endedAtMs, endedAt, "running"), workflows.length + 1, "running", Math.max(0, endedAtMs - openWorkflow.startedAtMs), endedAt));
+    workflows.push(
+      closeWorkflowMetrics(
+        closeOpenChildMetrics(openWorkflow, endedAtMs, endedAt, "running"),
+        workflows.length + 1,
+        "running",
+        Math.max(0, endedAtMs - openWorkflow.startedAtMs),
+        endedAt
+      )
+    );
   }
-  const workflowsMs = workflows.reduce((sum, workflow) => sum + workflow.wallMs, 0);
-  const agentsMs = workflows.reduce((sum, workflow) => sum + workflow.agentsMs, 0);
-  const commandsMs = workflows.reduce((sum, workflow) => sum + workflow.commandsMs, 0);
+  const workflowsMs = workflows.reduce(
+    (sum, workflow) => sum + workflow.wallMs,
+    0
+  );
+  const agentsMs = workflows.reduce(
+    (sum, workflow) => sum + workflow.agentsMs,
+    0
+  );
+  const commandsMs = workflows.reduce(
+    (sum, workflow) => sum + workflow.commandsMs,
+    0
+  );
   const wallMs = Math.max(0, endedAtMs - startedAtMs);
   return {
     status: state.status ?? "running",
@@ -102,10 +154,14 @@ function calculateRunMetrics(events, state, now) {
 }
 async function readRunStateSnapshot(currentRoot) {
   try {
-    return JSON.parse(await readFile(join(currentRoot, RUN_STATE_FILE_NAME), "utf8"));
+    return JSON.parse(
+      await readFile(join(currentRoot, RUN_STATE_FILE_NAME), "utf8")
+    );
   } catch (error) {
     if (!isNodeError(error) || error.code !== "ENOENT") throw error;
-    return JSON.parse(await readFile(join(currentRoot, LEGACY_RUN_STATE_FILE_NAME), "utf8"));
+    return JSON.parse(
+      await readFile(join(currentRoot, LEGACY_RUN_STATE_FILE_NAME), "utf8")
+    );
   }
 }
 async function readManifestEvents(path) {
@@ -127,32 +183,59 @@ function createSyntheticWorkflowMetrics(workflowId, runStartedAtMs, runEndedAtMs
 function startAgentMetrics(workflow, event, now) {
   return {
     ...workflow,
-    openAgents: [...workflow.openAgents, {
-      label: stringField(event.label, "unknown"),
-      startedAt: isoTime(event.at, now),
-      startedAtMs: timestampMs(event.at) ?? now.getTime()
-    }]
+    openAgents: [
+      ...workflow.openAgents,
+      {
+        label: stringField(event.label, "unknown"),
+        startedAt: isoTime(event.at, now),
+        startedAtMs: timestampMs(event.at) ?? now.getTime()
+      }
+    ]
   };
 }
 function finishAgentMetrics(workflow, event, usage, now) {
-  const [agent, openAgents] = takeOpenChild(workflow.openAgents, stringField(event.label, "unknown"));
-  const closedAgent = closeAgentMetrics(event, workflow.agents.length + 1, usage, now, agent);
+  const [agent, openAgents] = takeOpenChild(
+    workflow.openAgents,
+    stringField(event.label, "unknown")
+  );
+  const closedAgent = closeAgentMetrics(
+    event,
+    workflow.agents.length + 1,
+    usage,
+    now,
+    agent
+  );
   return { ...workflow, agents: [...workflow.agents, closedAgent], openAgents };
 }
 function startCommandMetrics(workflow, event, now) {
   return {
     ...workflow,
-    openCommands: [...workflow.openCommands, {
-      label: stringField(event.label, "unknown"),
-      startedAt: isoTime(event.at, now),
-      startedAtMs: timestampMs(event.at) ?? now.getTime()
-    }]
+    openCommands: [
+      ...workflow.openCommands,
+      {
+        label: stringField(event.label, "unknown"),
+        startedAt: isoTime(event.at, now),
+        startedAtMs: timestampMs(event.at) ?? now.getTime()
+      }
+    ]
   };
 }
 function finishCommandMetrics(workflow, event, now) {
-  const [command, openCommands] = takeOpenChild(workflow.openCommands, stringField(event.label, "unknown"));
-  const closedCommand = closeCommandMetrics(event, workflow.commands.length + 1, now, command);
-  return { ...workflow, commands: [...workflow.commands, closedCommand], openCommands };
+  const [command, openCommands] = takeOpenChild(
+    workflow.openCommands,
+    stringField(event.label, "unknown")
+  );
+  const closedCommand = closeCommandMetrics(
+    event,
+    workflow.commands.length + 1,
+    now,
+    command
+  );
+  return {
+    ...workflow,
+    commands: [...workflow.commands, closedCommand],
+    openCommands
+  };
 }
 function closeOpenChildMetrics(workflow, endedAtMs, endedAt, status) {
   return {
@@ -185,8 +268,14 @@ function closeOpenChildMetrics(workflow, endedAtMs, endedAt, status) {
   };
 }
 function closeWorkflowMetrics(workflow, index, status, wallMs, endedAt) {
-  const agentsMs = workflow.agents.reduce((sum, agent) => sum + agent.wallMs, 0);
-  const commandsMs = workflow.commands.reduce((sum, command) => sum + command.wallMs, 0);
+  const agentsMs = workflow.agents.reduce(
+    (sum, agent) => sum + agent.wallMs,
+    0
+  );
+  const commandsMs = workflow.commands.reduce(
+    (sum, command) => sum + command.wallMs,
+    0
+  );
   return {
     index,
     workflowId: workflow.workflowId,
@@ -197,7 +286,10 @@ function closeWorkflowMetrics(workflow, index, status, wallMs, endedAt) {
     ownMs: Math.max(0, wallMs - agentsMs - commandsMs),
     agentsMs,
     commandsMs,
-    agentUsage: workflow.agents.reduce((sum, agent) => addAgentUsage(sum, agent.usage), emptyAgentUsage()),
+    agentUsage: workflow.agents.reduce(
+      (sum, agent) => addAgentUsage(sum, agent.usage),
+      emptyAgentUsage()
+    ),
     agents: workflow.agents,
     commands: workflow.commands
   };
@@ -226,13 +318,19 @@ function closeCommandMetrics(event, index, now, openCommand) {
     startedAt: openCommand?.startedAt ?? isoTimeFromMs(Math.max(0, endedAtMs - wallMs)),
     endedAt: isoTime(event.at, now),
     wallMs,
-    ...event.type === "command.completed" ? { exitCode: nullableNumberField(event.exitCode), killed: booleanField(event.killed) } : {}
+    ...event.type === "command.completed" ? {
+      exitCode: nullableNumberField(event.exitCode),
+      killed: booleanField(event.killed)
+    } : {}
   };
 }
 function takeOpenChild(children, label) {
   const index = children.findIndex((child) => child.label === label);
   if (index === -1) return [void 0, children];
-  return [children[index], [...children.slice(0, index), ...children.slice(index + 1)]];
+  return [
+    children[index],
+    [...children.slice(0, index), ...children.slice(index + 1)]
+  ];
 }
 function workflowTerminalStatus(type) {
   if (type === "workflow.completed") return "completed";
@@ -241,8 +339,10 @@ function workflowTerminalStatus(type) {
   return void 0;
 }
 function runEndedAt(state) {
-  if (state.status === "completed") return state.outcome?.completedAt ?? state.updatedAt;
-  if (state.status === "failed") return state.failed?.failedAt ?? state.outcome?.completedAt ?? state.updatedAt;
+  if (state.status === "completed")
+    return state.outcome?.completedAt ?? state.updatedAt;
+  if (state.status === "failed")
+    return state.failed?.failedAt ?? state.outcome?.completedAt ?? state.updatedAt;
   return void 0;
 }
 function agentUsageFromEvent(event) {

package/dist/internal/pi-assets.js

@@ -1,6 +1,15 @@
 // src/internal/pi-assets.ts
 import { createHash } from "node:crypto";
-import { lstat, mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import {
+  lstat,
+  mkdir,
+  mkdtemp,
+  readFile,
+  readdir,
+  rename,
+  rm,
+  writeFile
+} from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { gunzipSync } from "node:zlib";
 
@@ -11,15 +20,28 @@ function isNodeError(error) {
 
 // src/internal/pi-assets.ts
 function resolvePiAssetsCacheRoot(input) {
-  if (input.environment.NORN_PI_CACHE_DIR) return resolve(input.environment.NORN_PI_CACHE_DIR);
-  if (input.platform === "darwin") return join(input.home, "Library", "Caches", "norn", "pi");
-  if (input.platform === "win32") return join(input.environment.LOCALAPPDATA || join(input.home, "AppData", "Local"), "norn", "pi");
+  if (input.environment.NORN_PI_CACHE_DIR)
+    return resolve(input.environment.NORN_PI_CACHE_DIR);
+  if (input.platform === "darwin")
+    return join(input.home, "Library", "Caches", "norn", "pi");
+  if (input.platform === "win32")
+    return join(
+      input.environment.LOCALAPPDATA || join(input.home, "AppData", "Local"),
+      "norn",
+      "pi"
+    );
   const xdgCache = input.environment.XDG_CACHE_HOME;
-  return join(xdgCache?.startsWith("/") ? xdgCache : join(input.home, ".cache"), "norn", "pi");
+  return join(
+    xdgCache?.startsWith("/") ? xdgCache : join(input.home, ".cache"),
+    "norn",
+    "pi"
+  );
 }
 async function materializePiAssets(input) {
   const digest = createHash("sha256").update(input.archive).digest("hex");
-  const files = JSON.parse(gunzipSync(Buffer.from(input.archive, "base64")).toString("utf8"));
+  const files = JSON.parse(
+    gunzipSync(Buffer.from(input.archive, "base64")).toString("utf8")
+  );
   const expectedFiles = /* @__PURE__ */ new Map();
   for (const file of files) {
     if (!file.path || file.path.includes("\\") || file.path.includes(":") || file.path.split("/").some((part) => !part || part === "." || part === "..") || expectedFiles.has(file.path)) {
@@ -27,7 +49,11 @@ async function materializePiAssets(input) {
     }
     expectedFiles.set(file.path, Buffer.from(file.content, "base64"));
   }
-  return new PiAssetCache({ cacheRoot: input.cacheRoot, digest, expectedFiles }).materialize();
+  return new PiAssetCache({
+    cacheRoot: input.cacheRoot,
+    digest,
+    expectedFiles
+  }).materialize();
 }
 var PiAssetCache = class {
   constructor(input) {
@@ -38,21 +64,32 @@ var PiAssetCache = class {
   root;
   async materialize() {
     await mkdir(this.input.cacheRoot, { recursive: true, mode: 448 });
-    if (!(await lstat(this.input.cacheRoot)).isDirectory()) throw new Error("Pi asset cache root must be a real directory");
+    if (!(await lstat(this.input.cacheRoot)).isDirectory())
+      throw new Error("Pi asset cache root must be a real directory");
     if (await this.validateExistingCache()) return this.root;
     const staging = await mkdtemp(join(this.input.cacheRoot, ".extract-"));
     try {
       for (const [path, content] of this.input.expectedFiles) {
         const parts = path.split("/");
-        await mkdir(join(staging, ...parts.slice(0, -1)), { recursive: true, mode: 448 });
-        await writeFile(join(staging, ...parts), content, { flag: "wx", mode: 384 });
+        await mkdir(join(staging, ...parts.slice(0, -1)), {
+          recursive: true,
+          mode: 448
+        });
+        await writeFile(join(staging, ...parts), content, {
+          flag: "wx",
+          mode: 384
+        });
       }
       try {
         await rename(staging, this.root);
       } catch (error) {
-        if (!isNodeError(error) || !["EEXIST", "ENOTEMPTY", "EPERM", "EACCES"].includes(error.code ?? "") || !await this.validateExistingCache()) throw error;
+        if (!isNodeError(error) || !["EEXIST", "ENOTEMPTY", "EPERM", "EACCES"].includes(
+          error.code ?? ""
+        ) || !await this.validateExistingCache())
+          throw error;
       }
-      if (!await this.validateExistingCache()) throw new Error("Pi assets disappeared after extraction");
+      if (!await this.validateExistingCache())
+        throw new Error("Pi assets disappeared after extraction");
       return this.root;
     } finally {
       await rm(staging, { recursive: true, force: true });
@@ -60,32 +97,46 @@ var PiAssetCache = class {
   }
   async validateExistingCache() {
     try {
-      if (!(await lstat(this.root)).isDirectory()) throw this.invalidCacheError();
+      if (!(await lstat(this.root)).isDirectory())
+        throw this.invalidCacheError();
     } catch (error) {
       if (isNodeError(error) && error.code === "ENOENT") return false;
       throw error;
     }
     const seen = /* @__PURE__ */ new Set();
     await this.validateDirectory({ directory: this.root, prefix: "", seen });
-    if (seen.size !== this.input.expectedFiles.size) throw this.invalidCacheError();
+    if (seen.size !== this.input.expectedFiles.size)
+      throw this.invalidCacheError();
     return true;
   }
   async validateDirectory(input) {
-    for (const entry of await readdir(input.directory, { withFileTypes: true })) {
+    for (const entry of await readdir(input.directory, {
+      withFileTypes: true
+    })) {
       const path = input.prefix ? `${input.prefix}/${entry.name}` : entry.name;
       const absolutePath = join(input.directory, entry.name);
       if (entry.isDirectory()) {
-        if (![...this.input.expectedFiles.keys()].some((file) => file.startsWith(`${path}/`))) throw this.invalidCacheError();
-        await this.validateDirectory({ directory: absolutePath, prefix: path, seen: input.seen });
+        if (![...this.input.expectedFiles.keys()].some(
+          (file) => file.startsWith(`${path}/`)
+        ))
+          throw this.invalidCacheError();
+        await this.validateDirectory({
+          directory: absolutePath,
+          prefix: path,
+          seen: input.seen
+        });
       } else {
         const expected = this.input.expectedFiles.get(path);
-        if (!entry.isFile() || !expected || !(await readFile(absolutePath)).equals(expected)) throw this.invalidCacheError();
+        if (!entry.isFile() || !expected || !(await readFile(absolutePath)).equals(expected))
+          throw this.invalidCacheError();
         input.seen.add(path);
       }
     }
   }
   invalidCacheError() {
-    return new Error(`Bundled Pi assets are incomplete or modified: ${this.root}. Remove this cache entry and retry.`);
+    return new Error(
+      `Bundled Pi assets are incomplete or modified: ${this.root}. Remove this cache entry and retry.`
+    );
   }
 };
 export {