panoma 0.1.8 → 0.9.0

package/app/node_modules/@panoma/apps/dist/index.js

@@ -0,0 +1,889 @@
+import {
+  APP_FAULTS,
+  AppFault,
+  FAULT_PART,
+  HOST_FAULTS,
+  MANAGER_FAULTS,
+  asAppFault,
+  faultOf,
+  isAppFaultCode
+} from "./chunk-4G5NKAON.js";
+
+// src/manifest.ts
+import { z } from "zod";
+var localized = z.object({ en: z.string().min(1).max(2e3), es: z.string().min(1).max(2e3) }).strict();
+var slug = z.string().regex(/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/).max(80);
+var relativeFile = z.string().max(200).refine((value) => /^[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)*$/.test(value) && !value.split("/").some((piece) => piece === "." || piece === ".."), "Expected a contained relative file path");
+var requirement = z.discriminatedUnion("kind", [
+  z.object({
+    id: slug,
+    kind: z.literal("playwright-browser"),
+    browser: z.literal("chromium"),
+    approxMB: z.number().int().positive().max(1e4),
+    termsUrl: z.string().url().refine((value) => new URL(value).protocol === "https:", "HTTPS required"),
+    note: localized
+  }).strict(),
+  z.object({
+    id: slug,
+    kind: z.literal("executable"),
+    names: z.array(z.enum(["ffmpeg", "ffprobe"])).min(1).max(2),
+    minVersion: z.string().regex(/^\d+\.\d+(?:\.\d+)?$/),
+    install: localized
+  }).strict()
+]);
+var AppManifestSchema = z.object({
+  id: slug,
+  protocol: z.string().regex(/^\d+$/).max(8),
+  entry: z.object({ mcp: relativeFile }).strict(),
+  displayName: localized,
+  summary: localized,
+  requirements: z.array(requirement).max(10),
+  providers: z.array(z.discriminatedUnion("kind", [
+    z.object({ id: z.literal("brain"), kind: z.literal("text-model"), default: z.literal("none"), sends: localized }).strict(),
+    z.object({ id: z.literal("voice"), kind: z.literal("elevenlabs"), default: z.literal("off"), sends: localized, env: z.literal("ELEVENLABS_API_KEY") }).strict()
+  ])).max(2),
+  storage: z.object({ home: z.literal("PANOMA_VIDEO_HOME"), browsers: z.literal("PLAYWRIGHT_BROWSERS_PATH") }).strict(),
+  actions: z.array(z.object({
+    id: z.literal("create-video"),
+    tool: z.literal("panoma_video_auto"),
+    surface: z.literal("project"),
+    label: localized
+  }).strict()).max(1),
+  legal: z.object({ license: relativeFile, notices: relativeFile, codecs: relativeFile }).strict()
+}).strict().superRefine((manifest, context) => {
+  for (const field of ["requirements", "providers", "actions"]) {
+    const ids = manifest[field].map((item) => item.id);
+    if (new Set(ids).size !== ids.length) context.addIssue({ code: "custom", path: [field], message: "Duplicate ids" });
+  }
+});
+function validateManifest(pkgJson) {
+  try {
+    return z.object({ panoma: z.object({ app: AppManifestSchema }).strict() }).parse(pkgJson).panoma.app;
+  } catch (error) {
+    if (error instanceof AppFault) throw error;
+    throw new AppFault("broken-package-manifest");
+  }
+}
+var VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z]+(?:[.-][0-9A-Za-z]+)*)?(?:\+[0-9A-Za-z]+(?:[.-][0-9A-Za-z]+)*)?$/;
+function assertVersion(version) {
+  if (!VERSION_PATTERN.test(version) || version.length > 100) throw new AppFault("invalid-version");
+  return version;
+}
+
+// src/official.ts
+var OFFICIAL = [
+  { id: "panoma-video", pkg: "@panoma/video", protocols: ["1"], data: "video" }
+];
+var NODE_FLOOR = { "panoma-video": ">=22.18" };
+function officialApp(id) {
+  const app = OFFICIAL.find((item) => item.id === id);
+  if (!app) throw new AppFault("unknown-app");
+  return app;
+}
+
+// src/layout.ts
+import { lstat, mkdir, readFile, realpath, rename, writeFile } from "fs/promises";
+import { dirname, isAbsolute, join, relative, sep } from "path";
+import { randomUUID } from "crypto";
+import { panomaPath } from "@panoma/core";
+function appsDir() {
+  return panomaPath("apps");
+}
+function layoutFor(id) {
+  const official = officialApp(id);
+  const root = join(appsDir(), id);
+  return {
+    root,
+    versions: join(root, "versions"),
+    current: join(root, "current.json"),
+    staged: join(root, "staged.json"),
+    browsers: join(root, "browsers"),
+    logs: join(root, "logs"),
+    data: panomaPath(official.data)
+  };
+}
+async function insideDir(root, child) {
+  try {
+    const [base, target] = await Promise.all([realpath(root), realpath(child)]);
+    const part = relative(base, target);
+    return part === "" || !isAbsolute(part) && part !== ".." && !part.startsWith(`..${sep}`);
+  } catch {
+    return false;
+  }
+}
+async function assertManagedPath(path) {
+  const base = panomaPath();
+  const part = relative(base, path);
+  if (isAbsolute(part) || part === ".." || part.startsWith(`..${sep}`)) throw new AppFault("path-outside-home");
+  let current = await realpath(base).catch((error) => {
+    if (error.code === "ENOENT") return base;
+    throw asAppFault(error);
+  });
+  for (const segment of part.split(sep).filter(Boolean)) {
+    current = join(current, segment);
+    const entry = await lstat(current).catch((error) => {
+      if (error.code === "ENOENT") return void 0;
+      throw asAppFault(error);
+    });
+    if (entry?.isSymbolicLink()) throw new AppFault("managed-path-is-symlink");
+  }
+}
+async function writeJsonAtomic(path, value) {
+  await assertManagedPath(path);
+  await mkdir(dirname(path), { recursive: true });
+  const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temp, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  } catch (error) {
+    throw asAppFault(error);
+  }
+  try {
+    await rename(temp, path);
+  } catch (error) {
+    const { rm: rm2 } = await import("fs/promises");
+    await rm2(temp, { force: true });
+    throw asAppFault(error);
+  }
+}
+async function readJson(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error instanceof SyntaxError ? new AppFault("disk-unreadable") : asAppFault(error);
+  }
+}
+
+// src/environment.ts
+var APP_ENV_NAMES = [
+  "PATH",
+  "HOME",
+  "LANG",
+  "LC_ALL",
+  "TMPDIR",
+  "TERM",
+  "SHELL",
+  "USER",
+  "CI",
+  "SystemRoot",
+  "windir",
+  "SystemDrive",
+  "ComSpec",
+  "PATHEXT",
+  "TEMP",
+  "TMP",
+  "APPDATA",
+  "LOCALAPPDATA",
+  "USERPROFILE",
+  "NUMBER_OF_PROCESSORS",
+  "PROCESSOR_ARCHITECTURE"
+];
+var SECRET_PATTERN = /TOKEN|KEY|SECRET|PASSWORD|PASSWD|CREDENTIAL|AUTH|SESSION|COOKIE/i;
+var PROVIDER_KEYS = /* @__PURE__ */ new Set(["ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GOOGLE_API_KEY", "GEMINI_API_KEY", "ELEVENLABS_API_KEY"]);
+function buildAppEnvironment(id, options = {}) {
+  const source = options.source ?? process.env;
+  const env = {};
+  for (const key of APP_ENV_NAMES) {
+    if (source[key] !== void 0 && !SECRET_PATTERN.test(key)) env[key] = source[key];
+  }
+  const layout = layoutFor(id);
+  env.PANOMA_VIDEO_HOME = layout.data;
+  env.PLAYWRIGHT_BROWSERS_PATH = layout.browsers;
+  env.PANOMA_VIDEO_BRAIN = options.brain ?? "none";
+  if (options.maxBrainCalls !== void 0) {
+    if (!Number.isInteger(options.maxBrainCalls) || options.maxBrainCalls < 0 || options.maxBrainCalls > 1e3) throw new AppFault("invalid-brain-budget");
+    env.PANOMA_VIDEO_MAX_BRAIN_CALLS = String(options.maxBrainCalls);
+  }
+  if (options.jobId) env.PANOMA_APP_JOB = options.jobId;
+  for (const [key, value] of Object.entries(options.providerEnv ?? {})) {
+    if (!PROVIDER_KEYS.has(key)) throw new AppFault("provider-key-not-allowed");
+    if (value) env[key] = value;
+  }
+  return env;
+}
+var appEnvironment = buildAppEnvironment;
+var GUIDE_TIMEOUT_MS = 6e4;
+var BROWSER_IDLE_MS = 5 * 6e4;
+var BROWSER_TOTAL_MS = 2 * 60 * 6e4;
+var TOOL_TIMEOUT_MS = {
+  panoma_video_auto: 30 * 6e4,
+  panoma_video_render: 30 * 6e4,
+  panoma_video_revise: 5 * 6e4,
+  panoma_video_review: 5 * 6e4,
+  panoma_video_scout: 2 * 6e4,
+  panoma_video_story: 5 * 6e4,
+  panoma_video_guide: GUIDE_TIMEOUT_MS
+};
+
+// src/registry.ts
+import { join as join2 } from "path";
+var NPM_REGISTRY = "https://registry.npmjs.org";
+var REGISTRY_TTL_MS = 24 * 60 * 6e4;
+function createRegistryClient(input) {
+  const ask = input.fetch ?? fetch;
+  const now = input.now ?? Date.now;
+  const pending = /* @__PURE__ */ new Map();
+  const memory = /* @__PURE__ */ new Map();
+  return {
+    async latest(pkg, options = {}) {
+      if (!OFFICIAL.some((app) => app.pkg === pkg)) throw new AppFault("unknown-app");
+      const key = `${appsDir()}:${pkg}`;
+      if (pending.has(key)) return pending.get(key);
+      const work = async () => {
+        const path = join2(appsDir(), "registry.json");
+        const all = await readJson(path).catch(() => void 0);
+        const raw = memory.get(key) ?? all?.[pkg];
+        let old;
+        if (raw && typeof raw.checkedAt === "string" && Number.isFinite(Date.parse(raw.checkedAt))) {
+          try {
+            if (raw.version) assertVersion(raw.version);
+            old = raw;
+          } catch {
+          }
+        }
+        const disabled = process.env.PANOMA_NO_UPDATE_CHECK === "1" && !options.explicit;
+        if (disabled || !options.force && old && now() - Date.parse(old.checkedAt) < REGISTRY_TTL_MS) {
+          return { ...old, stale: !old?.fetchedAt || old.checkedAt !== old.fetchedAt, disabled };
+        }
+        const checkedAt = new Date(now()).toISOString();
+        let fresh;
+        try {
+          const response = await ask(`${input.origin}/${encodeURIComponent(pkg)}/latest`, {
+            headers: { accept: "application/json" },
+            signal: AbortSignal.timeout(2e3),
+            redirect: "error"
+          });
+          if (!response.ok) throw new Error("registry-unavailable");
+          const reader = response.body?.getReader();
+          if (!reader) throw new Error("registry-empty-response");
+          let bytes = 0;
+          const chunks = [];
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              bytes += value.byteLength;
+              if (bytes > 65536) throw new Error("registry-response-too-large");
+              chunks.push(value);
+            }
+          } finally {
+            await reader.cancel().catch(() => void 0);
+          }
+          const body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+          if (body.name !== pkg || typeof body.version !== "string") throw new Error("registry-package-mismatch");
+          fresh = assertVersion(body.version);
+        } catch {
+        }
+        const next = {
+          checkedAt,
+          version: fresh ?? old?.version,
+          fetchedAt: fresh ? checkedAt : old?.fetchedAt
+        };
+        memory.set(key, next);
+        await writeJsonAtomic(path, { ...all && typeof all === "object" ? all : {}, [pkg]: next }).catch(() => void 0);
+        return { ...next, stale: !fresh, disabled: false };
+      };
+      const promise = work().finally(() => pending.delete(key));
+      pending.set(key, promise);
+      return promise;
+    }
+  };
+}
+var registry = createRegistryClient({ origin: NPM_REGISTRY });
+function registryVersion(pkg, options) {
+  return registry.latest(pkg, options);
+}
+async function latestOnRegistry(pkg, options) {
+  return (await registryVersion(pkg, options)).version;
+}
+
+// src/engines.ts
+function triple(value) {
+  const found = /^(?:v|>=|\^|~)?\s*(\d+)\.(\d+)(?:\.(\d+))?/.exec(value.trim());
+  if (!found) return void 0;
+  return [Number(found[1]), Number(found[2]), Number(found[3] ?? 0)];
+}
+function under(floor, running) {
+  const want = triple(floor);
+  const have = triple(running);
+  if (!want || !have) return false;
+  return rank(have) < rank(want);
+}
+function rank([major, minor, patch]) {
+  return major * 1e6 + minor * 1e3 + patch;
+}
+function nodeFloorFault(id, running = process.version) {
+  const needed = NODE_FLOOR[id];
+  if (!needed || !under(needed, running)) return void 0;
+  return new AppFault("node-too-old", needed + FAULT_PART + running);
+}
+function engineFault(tail) {
+  if (!/\bEBADENGINE\b/.test(tail)) return void 0;
+  const need = engineRecord(/Required:\s*(\{.*?\})/.exec(tail)?.[1]);
+  const have = engineRecord(/Actual:\s*(\{.*?\})/.exec(tail)?.[1]);
+  for (const name of ["node", "npm"]) {
+    const floor = need[name];
+    const running = have[name];
+    if (!floor || !running || !under(floor, running)) continue;
+    const code = name === "node" ? "node-too-old" : "npm-too-old";
+    return new AppFault(code, floor + FAULT_PART + running);
+  }
+  return new AppFault("engine-unsupported");
+}
+function engineRecord(source) {
+  if (!source) return {};
+  try {
+    const parsed = JSON.parse(source);
+    if (!parsed || typeof parsed !== "object") return {};
+    return Object.fromEntries(Object.entries(parsed).filter((entry) => typeof entry[1] === "string"));
+  } catch {
+    return {};
+  }
+}
+
+// src/process.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+import { findExecutable, resolveExecutable } from "@panoma/core";
+function findNpm(options = {}) {
+  const node = options.execPath ?? process.execPath;
+  const dir = dirname2(node);
+  const exists = options.exists ?? existsSync;
+  const env = options.env ?? process.env;
+  const scripts = [
+    join3(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js"),
+    join3(dir, "node_modules", "npm", "bin", "npm-cli.js")
+  ];
+  for (const script of scripts) {
+    if (exists(script)) return { file: node, args: [script], source: "adjacent-cli" };
+  }
+  const adjacent = join3(dir, process.platform === "win32" ? "npm.cmd" : "npm");
+  if (exists(adjacent)) return { ...resolveExecutable(adjacent, [], { env }), source: "adjacent-bin" };
+  const found = findExecutable("npm", { env });
+  return found ? { ...resolveExecutable(found, [], { env }), source: "path" } : void 0;
+}
+var PROCESS_GUARDIAN = [
+  'const {spawn}=require("node:child_process");const {writeFileSync}=require("node:fs");',
+  "const parent=process.ppid;const lease=process.argv[1];",
+  'if(lease)writeFileSync(lease,String(process.pid),{mode:0o600,flag:"wx"});',
+  'const child=spawn(process.argv[2],process.argv.slice(3),{env:process.env,cwd:process.cwd(),detached:process.platform!=="win32",stdio:["ignore","inherit","inherit"],windowsHide:true});',
+  "let closing=false;const watch=setInterval(()=>{try{process.kill(parent,0);if(process.ppid!==parent)stop(1)}catch{stop(1)}},250);",
+  "function stop(code=0){if(closing)return;closing=true;clearInterval(watch);",
+  "if(!child.pid){process.exit(code);return;}",
+  'if(process.platform==="win32"){const k=spawn("taskkill",["/T","/F","/PID",String(child.pid)],{windowsHide:true,stdio:"ignore"});k.on("error",()=>{child.kill();process.exit(code)});k.on("exit",()=>process.exit(code));}',
+  'else{try{process.kill(-child.pid,"SIGTERM")}catch{process.exit(code);return;}setTimeout(()=>{try{process.kill(-child.pid,"SIGKILL")}catch{}process.exit(code)},2000)}',
+  "}",
+  'process.stdin.on("end",()=>stop(1));process.stdin.on("error",()=>stop(1));process.stdin.resume();',
+  'process.stdout.on("error",()=>stop(1));process.stderr.on("error",()=>stop(1));',
+  'child.on("error",error=>{process.stderr.write(error.message);stop(1)});child.on("exit",code=>stop(code??1));',
+  'process.on("SIGTERM",()=>stop(1));process.on("SIGINT",()=>stop(1));'
+].join("\n");
+async function runProcess(request) {
+  request.signal?.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const argv = ["-e", PROCESS_GUARDIAN, "--", request.leasePath ?? "", request.file, ...request.args];
+    const child = spawn(process.execPath, argv, {
+      cwd: request.cwd,
+      env: request.env,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true,
+      detached: process.platform !== "win32"
+    });
+    let tail = "";
+    let aborted = false;
+    let timedOut = false;
+    let stalled = false;
+    const stop = () => {
+      child.stdin.end();
+    };
+    child.stdin.on("error", () => {
+    });
+    const cancel = () => {
+      aborted = true;
+      stop();
+    };
+    request.signal?.addEventListener("abort", cancel, { once: true });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      stop();
+    }, request.timeoutMs ?? 15 * 6e4);
+    timer.unref();
+    let idle;
+    const armIdle = () => {
+      if (!request.idleMs) return;
+      clearTimeout(idle);
+      idle = setTimeout(() => {
+        timedOut = true;
+        stalled = true;
+        stop();
+      }, request.idleMs);
+      idle.unref();
+    };
+    armIdle();
+    const output = (chunk) => {
+      const text = chunk.toString("utf8");
+      tail = (tail + text).slice(-65536);
+      for (const line of text.split(/\r?\n/).filter(Boolean)) request.onProgress?.(line.slice(0, 2e3));
+      armIdle();
+    };
+    child.stdout.on("data", output);
+    child.stderr.on("data", output);
+    const cleanup = () => {
+      clearTimeout(timer);
+      clearTimeout(idle);
+      request.signal?.removeEventListener("abort", cancel);
+    };
+    child.once("error", (error) => {
+      cleanup();
+      reject(asAppFault(error, "command-did-not-start"));
+    });
+    child.once("close", (code) => {
+      cleanup();
+      if (aborted) reject(new AppFault("cancelled"));
+      else if (timedOut) reject(stalled ? new AppFault("stalled", (tail.trim().split(/\r?\n/).pop() ?? "").trim().slice(0, 300)) : new AppFault("timeout"));
+      else if (code !== 0) reject(engineFault(tail) ?? new AppFault("process-failed", tail.trim() || String(code)));
+      else resolve();
+    });
+    if (request.signal?.aborted) cancel();
+  });
+}
+
+// src/manager.ts
+import { lstat as lstat2, mkdir as mkdir2, readdir, readFile as readFile2, rename as rename2, rm, stat, writeFile as writeFile2 } from "fs/promises";
+import { join as join4 } from "path";
+import { z as z2 } from "zod";
+function readIds(requirements) {
+  const shape = z2.object({ id: z2.string(), present: z2.boolean() }).passthrough();
+  try {
+    return z2.array(shape).max(10).parse(requirements).map((item) => item.id);
+  } catch {
+    throw new AppFault("malformed-requirements");
+  }
+}
+async function checkedProbe(app, probe, parent) {
+  parent?.throwIfAborted();
+  const deadline = AbortSignal.timeout(GUIDE_TIMEOUT_MS);
+  const signal = parent ? AbortSignal.any([parent, deadline]) : deadline;
+  let abort;
+  try {
+    const cancelled = new Promise((_resolve, reject) => {
+      abort = () => reject(parent?.aborted ? new AppFault("cancelled") : new AppFault("does-not-start", "guide timeout"));
+      signal.addEventListener("abort", abort, { once: true });
+    });
+    const requirements = await Promise.race([probe(app, signal), cancelled]);
+    const ids = readIds(requirements);
+    const declared = app.manifest.requirements.map((item) => item.id);
+    if (new Set(ids).size !== ids.length || declared.some((id) => !ids.includes(id))) {
+      throw new AppFault("malformed-requirements");
+    }
+    return requirements;
+  } finally {
+    if (abort) signal.removeEventListener("abort", abort);
+  }
+}
+var currentSchema = z2.object({
+  version: z2.string().transform(assertVersion),
+  activatedAt: z2.string().datetime(),
+  previous: z2.string().transform(assertVersion).optional()
+}).strict();
+async function readCurrent(id) {
+  const path = layoutFor(id).current;
+  await assertManagedPath(path);
+  const raw = await readJson(path);
+  if (raw === void 0) return void 0;
+  try {
+    return currentSchema.parse(raw);
+  } catch (error) {
+    throw error instanceof AppFault ? error : new AppFault("disk-unreadable");
+  }
+}
+async function readStaged(id) {
+  const path = layoutFor(id).staged;
+  await assertManagedPath(path);
+  const raw = await readJson(path);
+  if (raw === void 0) return void 0;
+  try {
+    return z2.object({ version: z2.string().transform(assertVersion) }).strict().parse(raw).version;
+  } catch (error) {
+    throw error instanceof AppFault ? error : new AppFault("disk-unreadable");
+  }
+}
+async function inspectAt(id, version, root) {
+  const official = officialApp(id);
+  assertVersion(version);
+  await assertManagedPath(root);
+  const packageRoot = join4(root, "node_modules", ...official.pkg.split("/"));
+  if (!await insideDir(root, packageRoot)) throw new AppFault("package-outside-installation");
+  const declared = await readFile2(join4(packageRoot, "package.json"), "utf8");
+  let pkg;
+  try {
+    pkg = JSON.parse(declared);
+  } catch {
+    throw new AppFault("broken-package-manifest");
+  }
+  if (pkg.name !== official.pkg || pkg.version !== version) throw new AppFault("package-version-mismatch");
+  const manifest = validateManifest(pkg);
+  if (manifest.id !== id) throw new AppFault("manifest-id-mismatch");
+  if (!official.protocols.includes(manifest.protocol)) throw new AppFault("incompatible-protocol");
+  for (const path of [manifest.entry.mcp, ...Object.values(manifest.legal)]) {
+    const file = join4(packageRoot, path);
+    const contained = await insideDir(packageRoot, file);
+    if (!contained || !(await stat(file)).isFile()) throw new AppFault("manifest-file-missing-or-outside");
+  }
+  return { id, pkg: official.pkg, version, manifest, root, packageRoot, entry: join4(packageRoot, manifest.entry.mcp) };
+}
+async function installedApp(id, version) {
+  const selected = version ?? (await readCurrent(id))?.version;
+  if (!selected) throw new AppFault("not-installed");
+  return inspectAt(id, assertVersion(selected), join4(layoutFor(id).versions, selected));
+}
+function alive(pid) {
+  if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid < 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function locked(id, work) {
+  const layout = layoutFor(id);
+  await assertManagedPath(layout.root);
+  await mkdir2(layout.root, { recursive: true });
+  const lock = join4(layout.root, ".operation-lock");
+  await assertManagedPath(lock);
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      await mkdir2(lock);
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw asAppFault(error);
+      if (attempt) throw new AppFault("app-operation-in-progress", void 0, { cause: error });
+      await reconcileDisk();
+    }
+  }
+  try {
+    await writeFile2(join4(lock, "pid"), String(process.pid));
+    return await work();
+  } finally {
+    await rm(lock, { recursive: true, force: true });
+  }
+}
+async function activateUnlocked(id, version) {
+  await installedApp(id, version);
+  const previous = await readCurrent(id);
+  const fallback = previous?.version && previous.version !== version ? previous.version : previous?.previous;
+  await writeJsonAtomic(layoutFor(id).current, {
+    version,
+    activatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...fallback ? { previous: fallback } : {}
+  });
+  if (await readStaged(id) === version) await rm(layoutFor(id).staged, { force: true });
+}
+async function activate(id, version) {
+  return locked(id, () => activateUnlocked(id, assertVersion(version)));
+}
+async function rollback(id) {
+  return locked(id, async () => {
+    const current = await readCurrent(id);
+    if (!current?.previous) throw new AppFault("no-previous-version");
+    await activateUnlocked(id, current.previous);
+  });
+}
+function createAppManager(dependencies) {
+  return {
+    async install(id, options) {
+      const official = officialApp(id);
+      return locked(id, async () => {
+        options.signal?.throwIfAborted();
+        const asked = await dependencies.registry.latest(official.pkg, { explicit: true, force: true });
+        const selected = options.version ?? asked.version;
+        if (!selected) throw new AppFault("offline");
+        const version = assertVersion(selected);
+        const layout = layoutFor(id);
+        const partial = join4(layout.versions, `${version}.partial`);
+        const final = join4(layout.versions, version);
+        await assertManagedPath(partial);
+        await mkdir2(layout.versions, { recursive: true });
+        let app;
+        let requirements;
+        if (await stat(final).then(() => true, () => false)) {
+          app = await installedApp(id, version);
+          requirements = await checkedProbe(app, options.probe, options.signal);
+        } else {
+          await rm(partial, { recursive: true, force: true });
+          await mkdir2(partial);
+          try {
+            const npm = findNpm();
+            if (!npm) throw new AppFault("npm-not-found");
+            if (dependencies.registryOrigin === NPM_REGISTRY) {
+              const floor = nodeFloorFault(id);
+              if (floor) throw floor;
+            }
+            const home = join4(partial, ".npm-home");
+            await mkdir2(home);
+            const config = join4(home, "npmrc");
+            await writeFile2(config, "", { mode: 384 });
+            const globalConfig = join4(home, "global-npmrc");
+            await writeFile2(globalConfig, "", { mode: 384 });
+            const env = buildAppEnvironment(id);
+            env.HOME = home;
+            env.USERPROFILE = home;
+            env.npm_config_cache = join4(home, "cache");
+            env.npm_config_userconfig = config;
+            env.npm_config_globalconfig = globalConfig;
+            env.npm_config_registry = dependencies.registryOrigin;
+            const args = [
+              "install",
+              "--prefix",
+              partial,
+              "--ignore-scripts",
+              "--engine-strict",
+              "--no-audit",
+              "--no-fund",
+              "--no-package-lock",
+              "--fetch-retries=0",
+              "--registry",
+              dependencies.registryOrigin,
+              `${official.pkg}@${version}`
+            ];
+            const leasePath = join4(layout.root, ".operation-lock", "worker.pid");
+            await assertManagedPath(leasePath);
+            await dependencies.run({
+              file: npm.file,
+              args: [...npm.args, ...args],
+              cwd: partial,
+              env,
+              signal: options.signal,
+              onProgress: options.onProgress,
+              leasePath
+            });
+            await rm(home, { recursive: true, force: true });
+            app = await inspectAt(id, version, partial);
+            await assertTreeContained(partial);
+            options.signal?.throwIfAborted();
+            requirements = await checkedProbe(app, options.probe, options.signal);
+            options.signal?.throwIfAborted();
+            await rename2(partial, final);
+            app = await installedApp(id, version);
+          } catch (error) {
+            await rm(partial, { recursive: true, force: true });
+            throw asAppFault(error);
+          }
+        }
+        options.signal?.throwIfAborted();
+        const before = await readCurrent(id);
+        if (options.activate === false) await writeJsonAtomic(layout.staged, { version });
+        else await activateUnlocked(id, version);
+        return {
+          ...app,
+          requirements,
+          previousVersion: before?.version,
+          status: options.activate === false ? "staged" : "installed"
+        };
+      });
+    },
+    async installBrowser(id, onProgress, signal) {
+      return locked(id, async () => {
+        const app = await installedApp(id);
+        const browser = app.manifest.requirements.find((item) => item.kind === "playwright-browser");
+        if (!browser || browser.kind !== "playwright-browser") throw new AppFault("browser-not-declared");
+        const candidates = [
+          join4(app.root, "node_modules", "playwright", "cli.js"),
+          join4(app.packageRoot, "node_modules", "playwright", "cli.js")
+        ];
+        const entry = await firstContainedFile(app.root, candidates);
+        if (!entry) throw new AppFault("playwright-not-installed");
+        const layout = layoutFor(id);
+        await assertManagedPath(layout.browsers);
+        await mkdir2(layout.browsers, { recursive: true });
+        const leasePath = join4(layoutFor(id).root, ".operation-lock", "worker.pid");
+        await assertManagedPath(leasePath);
+        await dependencies.run({
+          file: process.execPath,
+          args: [entry, "install", browser.browser],
+          cwd: app.root,
+          env: buildAppEnvironment(id),
+          onProgress,
+          signal,
+          leasePath,
+          // Hundreds of megabytes: what must not stop is the progress, not the clock.
+          idleMs: BROWSER_IDLE_MS,
+          timeoutMs: BROWSER_TOTAL_MS
+        });
+      });
+    }
+  };
+}
+var manager = createAppManager({
+  registry: { latest: registryVersion },
+  registryOrigin: NPM_REGISTRY,
+  run: runProcess
+});
+var install = manager.install;
+var installBrowser = manager.installBrowser;
+function update(id, options) {
+  return install(id, { ...options, activate: false });
+}
+async function probeRequirements(id, probe, signal) {
+  return checkedProbe(await installedApp(id), probe, signal);
+}
+async function firstContainedFile(root, candidates) {
+  for (const candidate of candidates) {
+    if (!await insideDir(root, candidate)) continue;
+    if (await stat(candidate).then((entry) => entry.isFile(), () => false)) return candidate;
+  }
+  return void 0;
+}
+async function assertTreeContained(root, path = root) {
+  for (const entry of await readdir(path, { withFileTypes: true })) {
+    const child = join4(path, entry.name);
+    if (entry.isSymbolicLink()) {
+      if (!await insideDir(root, child)) throw new AppFault("broken-installation");
+    } else if (entry.isDirectory()) await assertTreeContained(root, child);
+  }
+}
+async function subtreeBytes(path) {
+  const entries = await readdir(path, { withFileTypes: true }).catch((error) => {
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") return [];
+    throw asAppFault(error);
+  });
+  let bytes = 0;
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    const child = join4(path, entry.name);
+    if (entry.isDirectory()) bytes += await subtreeBytes(child);
+    else bytes += (await lstat2(child).catch((error) => {
+      if (error.code === "ENOENT") return void 0;
+      throw asAppFault(error);
+    }))?.size ?? 0;
+  }
+  return bytes;
+}
+async function directoryBytes(path) {
+  const entry = await lstat2(path).catch((error) => {
+    if (error.code === "ENOENT") return void 0;
+    throw asAppFault(error);
+  });
+  if (!entry || entry.isSymbolicLink()) return 0;
+  if (!entry.isDirectory()) return entry.size;
+  return subtreeBytes(path);
+}
+async function cleanData(id) {
+  return locked(id, async () => {
+    const data = layoutFor(id).data;
+    await assertManagedPath(data);
+    const removedBytes = await directoryBytes(data);
+    await rm(data, { recursive: true, force: true });
+    return { removedBytes };
+  });
+}
+async function uninstall(id, options = { keepData: true }) {
+  if (!options.keepData) throw new AppFault("use-clean-data");
+  return locked(id, async () => {
+    const layout = layoutFor(id);
+    for (const path of [layout.versions, layout.current, layout.staged, layout.browsers, layout.logs]) {
+      await assertManagedPath(path);
+      await rm(path, { recursive: true, force: true });
+    }
+  });
+}
+async function reconcileDisk() {
+  const result = { apps: [], removedPartials: 0 };
+  for (const official of OFFICIAL) {
+    const layout = layoutFor(official.id);
+    let current;
+    try {
+      await assertManagedPath(layout.root);
+      const lock = join4(layout.root, ".operation-lock");
+      const pid = Number(await readFile2(join4(lock, "pid"), "utf8").catch(() => "0"));
+      const workerPid = Number(await readFile2(join4(lock, "worker.pid"), "utf8").catch(() => "0"));
+      const lockEntry = await stat(lock).catch(() => void 0);
+      const busy = alive(pid) || alive(workerPid) || !!lockEntry && Date.now() - lockEntry.mtimeMs < 3e4;
+      if (!busy) {
+        if (lockEntry) await rm(lock, { recursive: true, force: true });
+        for (const name of await readdir(layout.versions).catch(() => [])) {
+          if (!name.endsWith(".partial")) continue;
+          const path = join4(layout.versions, name);
+          await assertManagedPath(path);
+          await rm(path, { recursive: true, force: true });
+          result.removedPartials += 1;
+        }
+      }
+      current = await readCurrent(official.id);
+      const app = current ? await installedApp(official.id, current.version) : void 0;
+      let stagedVersion;
+      let error;
+      try {
+        stagedVersion = await readStaged(official.id);
+        if (stagedVersion) await installedApp(official.id, stagedVersion);
+      } catch (caught) {
+        await assertManagedPath(layout.staged);
+        if (!busy) await rm(layout.staged, { force: true });
+        stagedVersion = void 0;
+        error = "staged-update-invalid: " + (caught instanceof Error ? caught.message : "unreadable");
+      }
+      if (!current) {
+        const status = error ? "broken" : stagedVersion ? "staged" : "absent";
+        result.apps.push({ id: official.id, status, stagedVersion, error });
+      } else {
+        const status = stagedVersion ? "staged" : "installed";
+        result.apps.push({ id: official.id, status, current, stagedVersion, app, error });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "disk-unreadable";
+      result.apps.push({ id: official.id, status: "broken", current, error: message });
+    }
+  }
+  return result;
+}
+export {
+  APP_ENV_NAMES,
+  APP_FAULTS,
+  AppFault,
+  AppManifestSchema,
+  BROWSER_IDLE_MS,
+  BROWSER_TOTAL_MS,
+  FAULT_PART,
+  GUIDE_TIMEOUT_MS,
+  HOST_FAULTS,
+  MANAGER_FAULTS,
+  NPM_REGISTRY,
+  OFFICIAL,
+  REGISTRY_TTL_MS,
+  SECRET_PATTERN,
+  TOOL_TIMEOUT_MS,
+  VERSION_PATTERN,
+  activate,
+  appEnvironment,
+  appsDir,
+  asAppFault,
+  assertManagedPath,
+  assertVersion,
+  buildAppEnvironment,
+  cleanData,
+  directoryBytes,
+  engineFault,
+  faultOf,
+  findNpm,
+  insideDir,
+  install,
+  installBrowser,
+  installedApp,
+  isAppFaultCode,
+  latestOnRegistry,
+  layoutFor,
+  nodeFloorFault,
+  officialApp,
+  probeRequirements,
+  readCurrent,
+  readStaged,
+  reconcileDisk,
+  registryVersion,
+  rollback,
+  uninstall,
+  update,
+  validateManifest
+};