pixelkiln 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -45,6 +45,8 @@ __export(index_exports, {
   PixelLabProvider: () => PixelLabProvider,
   StyleSchema: () => StyleSchema,
   UnsupportedCapabilityError: () => UnsupportedCapabilityError,
+  WorkspaceProjectSchema: () => WorkspaceProjectSchema,
+  WorkspaceSchema: () => WorkspaceSchema,
   adopt: () => adopt,
   applyTags: () => applyTags,
   auditStyle: () => auditStyle,
@@ -75,6 +77,8 @@ __export(index_exports, {
   loadClaims: () => loadClaims,
   loadLock: () => loadLock,
   loadManifest: () => loadManifest,
+  loadSiblingManifests: () => loadSiblingManifests,
+  loadWorkspace: () => loadWorkspace,
   lockKey: () => lockKey,
   matchOrphanStyle: () => matchOrphanStyle,
   measureBalanceChange: () => measureBalanceChange,
@@ -89,6 +93,7 @@ __export(index_exports, {
   packStyle: () => packStyle,
   paletteDistance: () => paletteDistance,
   parseLock: () => parseLock,
+  parseWorkspace: () => parseWorkspace,
   pngSize: () => pngSize,
   poll: () => poll,
   portableOutputPath: () => portableOutputPath,
@@ -102,6 +107,7 @@ __export(index_exports, {
   resolveEntryOutputs: () => resolveEntryOutputs,
   resolveOutputPath: () => resolveOutputPath,
   resolvePackInputs: () => resolvePackInputs,
+  resolveProject: () => resolveProject,
   resolveSpecEntryOutputs: () => resolveSpecEntryOutputs,
   resolveSpecOutputs: () => resolveSpecOutputs,
   resolveSpecs: () => resolveSpecs,
@@ -111,6 +117,7 @@ __export(index_exports, {
   runPicker: () => runPicker,
   runSalvage: () => runSalvage,
   saveLock: () => saveLock,
+  saveWorkspace: () => saveWorkspace,
   scanAssets: () => scanAssets,
   selectEntryOutput: () => selectEntryOutput,
   sha256: () => sha256,
@@ -126,11 +133,15 @@ __export(index_exports, {
   tileFeatureOutputCount: () => tileFeatureOutputCount,
   tileVariationCount: () => tileVariationCount,
   tilesCost: () => tilesCost,
+  toPortablePath: () => toPortablePath,
   totalSpend: () => totalSpend,
   upsert: () => upsert,
   validateCostEstimate: () => validateCostEstimate,
+  validateWorkspace: () => validateWorkspace,
   verifyArtifactBundle: () => verifyArtifactBundle,
   withArtifactManifest: () => withArtifactManifest,
+  workspaceClaims: () => workspaceClaims,
+  workspaceStatus: () => workspaceStatus,
   writeArtifactBundle: () => writeArtifactBundle,
   writeManagedArtifactBundle: () => writeManagedArtifactBundle
 });
@@ -547,11 +558,11 @@ var PixelLabClient = class {
    * common than the failure mode of retrying (a duplicate object), and a
    * duplicate is visible and free to delete whereas a silent gap is neither.
    */
-  async request(path15, init, attempt = 0) {
+  async request(path17, init, attempt = 0) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
     let res;
     try {
-      res = await fetch(`${BASE}${path15}`, {
+      res = await fetch(`${BASE}${path17}`, {
         ...init,
         signal: init?.signal ?? AbortSignal.timeout(this.timeoutMs),
         headers: {
@@ -563,24 +574,24 @@ var PixelLabClient = class {
     } catch (err) {
       if (attempt < MAX_RETRIES) {
         await sleep(backoffMs(attempt));
-        return this.request(path15, init, attempt + 1);
+        return this.request(path17, init, attempt + 1);
       }
       throw err;
     }
     if (!res.ok && shouldRetry(res.status) && attempt < MAX_RETRIES) {
       const waitMs = retryAfterMs(res.headers.get("retry-after")) ?? backoffMs(attempt);
       await sleep(waitMs);
-      return this.request(path15, init, attempt + 1);
+      return this.request(path17, init, attempt + 1);
     }
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path15} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path17} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path15} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path17} returned invalid JSON`);
     }
   }
   async balance() {
@@ -1598,8 +1609,8 @@ var import_promises = require("fs/promises");
 function sha256(data) {
   return (0, import_node_crypto3.createHash)("sha256").update(data).digest("hex");
 }
-async function sha256File(path15) {
-  return sha256(await (0, import_promises.readFile)(path15));
+async function sha256File(path17) {
+  return sha256(await (0, import_promises.readFile)(path17));
 }
 function specHash(spec, styleImageHashes) {
   return sha256(
@@ -2843,10 +2854,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path15) {
-  if (!(0, import_node_fs6.existsSync)(path15)) return { version: 1, hashes: {} };
+async function loadCache(path17) {
+  if (!(0, import_node_fs6.existsSync)(path17)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await (0, import_promises6.readFile)(path15, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await (0, import_promises6.readFile)(path17, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -2858,18 +2869,18 @@ async function loadCache(path15) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path15, cache) {
+async function saveCache(path17, cache) {
   const sorted = {};
   for (const key of Object.keys(cache.hashes).sort()) {
     const hash = cache.hashes[key];
     if (!isSha256Hash(hash)) throw new Error(`Refusing to cache invalid SHA-256 for ${key}`);
     sorted[key] = hash;
   }
-  await (0, import_promises6.mkdir)(import_node_path8.default.dirname(import_node_path8.default.resolve(path15)), { recursive: true });
-  const tmp = `${path15}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await (0, import_promises6.mkdir)(import_node_path8.default.dirname(import_node_path8.default.resolve(path17)), { recursive: true });
+  const tmp = `${path17}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await (0, import_promises6.writeFile)(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await (0, import_promises6.rename)(tmp, path15);
+    await (0, import_promises6.rename)(tmp, path17);
   } finally {
     await (0, import_promises6.rm)(tmp, { force: true });
   }
@@ -4602,6 +4613,7 @@ function mode(values) {
 // src/pipeline/salvage.ts
 var import_promises12 = require("fs/promises");
 var import_node_fs13 = require("fs");
+var import_node_path15 = __toESM(require("path"), 1);
 async function loadClaims(lockPaths) {
   const claimed = /* @__PURE__ */ new Set();
   for (const p of lockPaths) {
@@ -4654,6 +4666,26 @@ function matchOrphanStyle(prompt, manifest) {
   if (styleIds.length <= 1) return styleIds[0] ?? null;
   return matchStyleByPattern(prompt, manifest);
 }
+async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
+  const own = import_node_path15.default.resolve(ownManifestPath);
+  const siblingManifestPaths = [
+    .../* @__PURE__ */ new Set([
+      ...workspaceManifestPaths,
+      ...claimPaths.map((c) => import_node_path15.default.join(import_node_path15.default.dirname(import_node_path15.default.resolve(c)), "pixelkiln.manifest.json"))
+    ])
+  ];
+  const siblings = [];
+  for (const siblingManifestPath of siblingManifestPaths) {
+    if (import_node_path15.default.resolve(siblingManifestPath) === own) continue;
+    if (!(0, import_node_fs13.existsSync)(siblingManifestPath)) continue;
+    try {
+      const { manifest } = await loadManifest(siblingManifestPath);
+      siblings.push({ label: import_node_path15.default.basename(import_node_path15.default.dirname(siblingManifestPath)), manifest });
+    } catch {
+    }
+  }
+  return siblings;
+}
 function groupOrphansByStyle(orphans, manifest, siblings = []) {
   const matched = /* @__PURE__ */ new Map();
   const elsewhere = /* @__PURE__ */ new Map();
@@ -4765,7 +4797,7 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 
 // src/pick/salvage-server.ts
 var import_promises13 = require("fs/promises");
-var import_node_path15 = __toESM(require("path"), 1);
+var import_node_path16 = __toESM(require("path"), 1);
 
 // src/pick/salvage-sheet.ts
 var escapeHtml2 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -4930,7 +4962,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: import_node_path15.default.relative(process.cwd(), ctx.importDir) || "."
+    importDir: import_node_path16.default.relative(process.cwd(), ctx.importDir) || "."
   });
   const byId = new Map(orphans.map((o) => [o.id, o]));
   const existingTags = new Map(orphans.map((o) => [o.id, o.tags]));
@@ -4959,9 +4991,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
             if (!buf.subarray(0, 8).equals(PNG_SIGNATURE3)) throw new Error("not a PNG");
             decodePng(buf);
             const assetId = idFromPrompt(orphan.prompt, taken);
-            const rel = import_node_path15.default.join("_salvaged", `${assetId}.png`);
-            const outFile = import_node_path15.default.resolve(ctx.importDir, rel);
-            await (0, import_promises13.mkdir)(import_node_path15.default.dirname(outFile), { recursive: true });
+            const rel = import_node_path16.default.join("_salvaged", `${assetId}.png`);
+            const outFile = import_node_path16.default.resolve(ctx.importDir, rel);
+            await (0, import_promises13.mkdir)(import_node_path16.default.dirname(outFile), { recursive: true });
             await (0, import_promises13.writeFile)(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
@@ -4988,7 +5020,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               error: null,
               sourceUrl: orphan.previewUrl,
               outputs: [{
-                path: portableOutputPath(outFile, import_node_path15.default.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, import_node_path16.default.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -5020,6 +5052,233 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
     }
   });
 }
+
+// src/workspace.ts
+var import_promises14 = require("fs/promises");
+var import_node_fs14 = require("fs");
+var import_node_path17 = __toESM(require("path"), 1);
+var import_zod4 = require("zod");
+var WorkspaceProjectSchema = import_zod4.z.object({
+  id: import_zod4.z.string().min(1),
+  /** Manifest path, relative to the catalog file's own directory. */
+  manifest: import_zod4.z.string().min(1),
+  /** Lockfile path, relative to the catalog file's own directory. */
+  lock: import_zod4.z.string().min(1),
+  provider: import_zod4.z.string().min(1).default("pixellab"),
+  /** Free-form label for a shared account, e.g. distinguishing sandboxes. */
+  account: import_zod4.z.string().optional()
+}).strict();
+var WorkspaceSchema = import_zod4.z.object({
+  version: import_zod4.z.literal(1),
+  projects: import_zod4.z.array(WorkspaceProjectSchema).default([])
+}).strict();
+function parseWorkspace(raw) {
+  const parsed = WorkspaceSchema.safeParse(raw);
+  if (parsed.success) return parsed.data;
+  throw new Error(
+    `Workspace catalog is not valid v1:
+${parsed.error.issues.slice(0, 5).map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n")}`
+  );
+}
+async function loadWorkspace(workspacePath) {
+  if (!(0, import_node_fs14.existsSync)(workspacePath)) return { version: 1, projects: [] };
+  let raw;
+  try {
+    raw = JSON.parse(await (0, import_promises14.readFile)(workspacePath, "utf8"));
+  } catch (err) {
+    throw new Error(
+      `Workspace catalog at ${workspacePath} is malformed:
+${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return parseWorkspace(raw);
+}
+async function saveWorkspace(workspacePath, ws) {
+  const sorted = {
+    version: 1,
+    projects: [...ws.projects].sort((a, b) => a.id.localeCompare(b.id))
+  };
+  await (0, import_promises14.mkdir)(import_node_path17.default.dirname(import_node_path17.default.resolve(workspacePath)), { recursive: true });
+  const tmp = `${workspacePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    await (0, import_promises14.writeFile)(tmp, JSON.stringify(sorted, null, 2) + "\n");
+    await (0, import_promises14.rename)(tmp, workspacePath);
+  } finally {
+    await (0, import_promises14.rm)(tmp, { force: true });
+  }
+}
+function toPortablePath(dir, absolute) {
+  return import_node_path17.default.relative(dir, absolute).split(import_node_path17.default.sep).join("/");
+}
+function resolveProject(dir, project) {
+  return {
+    manifestPath: import_node_path17.default.resolve(dir, project.manifest.split("/").join(import_node_path17.default.sep)),
+    lockPath: import_node_path17.default.resolve(dir, project.lock.split("/").join(import_node_path17.default.sep))
+  };
+}
+function validateWorkspace(ws, dir) {
+  const diagnostics = [];
+  const idCounts = /* @__PURE__ */ new Map();
+  const lockOwners = /* @__PURE__ */ new Map();
+  const manifestOwners = /* @__PURE__ */ new Map();
+  for (const project of ws.projects) {
+    idCounts.set(project.id, (idCounts.get(project.id) ?? 0) + 1);
+    const { manifestPath, lockPath } = resolveProject(dir, project);
+    lockOwners.set(lockPath, [...lockOwners.get(lockPath) ?? [], project.id]);
+    manifestOwners.set(manifestPath, [...manifestOwners.get(manifestPath) ?? [], project.id]);
+    if (import_node_path17.default.isAbsolute(project.manifest) || import_node_path17.default.isAbsolute(project.lock)) {
+      diagnostics.push({
+        id: "absolute-path",
+        level: "warning",
+        message: `project "${project.id}" stores an absolute path \u2014 the catalog will not resolve correctly if this tree is cloned or moved elsewhere`
+      });
+    }
+    if (!(0, import_node_fs14.existsSync)(manifestPath)) {
+      diagnostics.push({
+        id: "missing-manifest",
+        level: "error",
+        message: `project "${project.id}" manifest not found: ${manifestPath}`
+      });
+    }
+    if (!(0, import_node_fs14.existsSync)(lockPath)) {
+      diagnostics.push({
+        id: "missing-lock",
+        level: "error",
+        message: `project "${project.id}" lockfile not found: ${lockPath}`
+      });
+    }
+  }
+  for (const [id, count] of idCounts) {
+    if (count > 1) {
+      diagnostics.push({
+        id: "duplicate-id",
+        level: "error",
+        message: `project id "${id}" is registered ${count} times`
+      });
+    }
+  }
+  for (const [lockPath, ids] of lockOwners) {
+    if (ids.length > 1) {
+      diagnostics.push({
+        id: "duplicate-lock",
+        level: "error",
+        message: `${ids.join(", ")} all register the same lockfile: ${lockPath}`
+      });
+    }
+  }
+  for (const [manifestPath, ids] of manifestOwners) {
+    if (ids.length > 1) {
+      diagnostics.push({
+        id: "duplicate-manifest",
+        level: "warning",
+        message: `${ids.join(", ")} share manifest ${manifestPath} \u2014 expected only when they are variant lockfiles beside one manifest`
+      });
+    }
+  }
+  const providers = new Set(ws.projects.map((p) => p.provider));
+  if (providers.size > 1) {
+    diagnostics.push({
+      id: "mixed-provider",
+      level: "warning",
+      message: `registered projects use different providers: ${[...providers].sort().join(", ")} \u2014 spend totals are kept separate per unit, but confirm this is intentional`
+    });
+  }
+  return diagnostics;
+}
+
+// src/pipeline/workspace.ts
+async function workspaceClaims(ws, dir) {
+  const lockPaths = [];
+  const byProject = {};
+  const claimed = /* @__PURE__ */ new Set();
+  for (const project of ws.projects) {
+    const { lockPath } = resolveProject(dir, project);
+    lockPaths.push(lockPath);
+    let projectClaims;
+    try {
+      projectClaims = await loadClaims([lockPath]);
+    } catch (err) {
+      throw new Error(
+        `Project "${project.id}" lockfile is unreadable: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    byProject[project.id] = projectClaims.size;
+    for (const id of projectClaims) claimed.add(id);
+  }
+  return { claimed, byProject, lockPaths };
+}
+function emptyStateCounts() {
+  return {
+    ok: 0,
+    missing: 0,
+    untracked: 0,
+    stale: 0,
+    orphaned: 0,
+    "in-flight": 0,
+    recoverable: 0,
+    failed: 0
+  };
+}
+async function workspaceStatus(ws, dir) {
+  const diagnostics = validateWorkspace(ws, dir);
+  const provider = PixelLabProvider.forOffline();
+  const projects = [];
+  const totalsByState = emptyStateCounts();
+  const totalsSpend = { generations: 0, usd: 0, free: 0 };
+  for (const project of ws.projects) {
+    const { manifestPath, lockPath } = resolveProject(dir, project);
+    const base = {
+      id: project.id,
+      provider: project.provider,
+      account: project.account ?? null,
+      manifest: manifestPath,
+      lock: lockPath
+    };
+    try {
+      const loaded = await loadManifest(manifestPath);
+      const specs = await resolveSpecs(loaded, { provider });
+      const lock = await loadLock(lockPath);
+      normalizeLockOutputPaths(lock, specs);
+      const plan = await buildPlan(specs, lock);
+      const byState = summarize(plan);
+      const spend = spendByUnit(lock);
+      for (const state of Object.keys(byState)) {
+        totalsByState[state] += byState[state];
+      }
+      for (const unit of Object.keys(spend)) {
+        totalsSpend[unit] += spend[unit];
+      }
+      projects.push({
+        ...base,
+        entries: Object.keys(lock.entries).length,
+        byState,
+        spendByUnit: spend,
+        error: null
+      });
+    } catch (err) {
+      projects.push({
+        ...base,
+        entries: 0,
+        byState: emptyStateCounts(),
+        spendByUnit: { generations: 0, usd: 0, free: 0 },
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  let claims = 0;
+  try {
+    claims = (await workspaceClaims(ws, dir)).claimed.size;
+  } catch {
+  }
+  return {
+    version: 1,
+    safe: !diagnostics.some((d) => d.level === "error") && projects.every((p) => !p.error),
+    dir,
+    projects,
+    totals: { byState: totalsByState, spendByUnit: totalsSpend, claims },
+    diagnostics
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AssetSchema,
@@ -5037,6 +5296,8 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   PixelLabProvider,
   StyleSchema,
   UnsupportedCapabilityError,
+  WorkspaceProjectSchema,
+  WorkspaceSchema,
   adopt,
   applyTags,
   auditStyle,
@@ -5067,6 +5328,8 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   loadClaims,
   loadLock,
   loadManifest,
+  loadSiblingManifests,
+  loadWorkspace,
   lockKey,
   matchOrphanStyle,
   measureBalanceChange,
@@ -5081,6 +5344,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   packStyle,
   paletteDistance,
   parseLock,
+  parseWorkspace,
   pngSize,
   poll,
   portableOutputPath,
@@ -5094,6 +5358,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   resolveEntryOutputs,
   resolveOutputPath,
   resolvePackInputs,
+  resolveProject,
   resolveSpecEntryOutputs,
   resolveSpecOutputs,
   resolveSpecs,
@@ -5103,6 +5368,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   runPicker,
   runSalvage,
   saveLock,
+  saveWorkspace,
   scanAssets,
   selectEntryOutput,
   sha256,
@@ -5118,11 +5384,15 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   tileFeatureOutputCount,
   tileVariationCount,
   tilesCost,
+  toPortablePath,
   totalSpend,
   upsert,
   validateCostEstimate,
+  validateWorkspace,
   verifyArtifactBundle,
   withArtifactManifest,
+  workspaceClaims,
+  workspaceStatus,
   writeArtifactBundle,
   writeManagedArtifactBundle
 });