@mean-weasel/lineage 0.1.1 → 0.1.3

package/dist/server.js

@@ -1,7 +1,7 @@
 // src/server.ts
 import express2 from "express";
 import multer from "multer";
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 import { join as join9 } from "node:path";
 
 // src/server/assetCore.ts
@@ -1015,7 +1015,14 @@ function escapeSvgText2(value) {
 function loadCatalog(project = defaultProject) {
   const path = catalogPath(project);
   if (existsSync3(path)) {
-    return normalizeCatalog(JSON.parse(readFileSync2(path, "utf8")), project);
+    try {
+      return normalizeCatalog(JSON.parse(readFileSync2(path, "utf8")), project);
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        throw new LineageAssetError(`Missing catalog: ${path}`, 404);
+      }
+      throw error;
+    }
   }
   const clean = cleanProject(project);
   if (clean === defaultProject) {
@@ -1924,6 +1931,16 @@ function updateAssetReview(project, fields) {
 }
 
 // src/server/assetLineageHandoff.ts
+var publicPackageCommand = "npx @mean-weasel/lineage";
+function shellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function lineageCommand(command, project, rootAssetId) {
+  return `${publicPackageCommand} ${command} --project ${shellQuote(project)} --root ${shellQuote(rootAssetId)} --db ${shellQuote(lineageDbPath())} --json`;
+}
+function linkChildCommand(project, rootAssetId) {
+  return `${publicPackageCommand} link-child --project ${shellQuote(project)} --root ${shellQuote(rootAssetId)} --child <asset-id> --confirm-write --db ${shellQuote(lineageDbPath())} --json`;
+}
 function getLineageBrief(project, rootAssetId) {
   const next = getLineageNextAsset(project, rootAssetId);
   const assets = next.next_assets;
@@ -1960,9 +1977,9 @@ function getLineageBrief(project, rootAssetId) {
       rationale
     },
     handoff: {
-      next_command: `npx lineage lineage next --project ${project} --root ${next.root_asset_id} --json`,
-      inspect_command: asset ? `npx lineage lineage inspect --project ${project} --asset-id ${asset.asset_id} --json` : void 0,
-      link_child_command: asset ? `npx lineage lineage link-child --project ${project} --root ${next.root_asset_id} --child <asset-id> --confirm-write --json` : void 0
+      next_command: lineageCommand("next", project, next.root_asset_id),
+      inspect_command: asset ? `${publicPackageCommand} inspect --project ${shellQuote(project)} --asset-id ${shellQuote(asset.asset_id)} --db ${shellQuote(lineageDbPath())} --json` : void 0,
+      link_child_command: asset ? linkChildCommand(project, next.root_asset_id) : void 0
     },
     fetchedAt: nowIso()
   };
@@ -2709,7 +2726,7 @@ function laneFor(channel, localAssets2, catalogAssets, limit) {
   };
 }
 function handoff(project) {
-  const prefix = `npx lineage`;
+  const prefix = `npx @mean-weasel/lineage`;
   return {
     backupTemplate: `${prefix} local backup --project ${project} --asset-id <local-id> --dry-run --json`,
     lineageNextTemplate: `${prefix} lineage next --project ${project} --root <root-id> --json`,
@@ -4510,11 +4527,14 @@ function listImageGenerationJobs(project = defaultProject, fields = {}) {
 
 // src/server/assetLineageDemo.ts
 import { createHash as createHash2 } from "node:crypto";
-import { mkdirSync as mkdirSync5, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname3, join as join8 } from "node:path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync5, mkdtempSync, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname as dirname3, join as join8, posix } from "node:path";
+import { gunzipSync } from "node:zlib";
 var demoWorkspaceTitle = "Demo: Content iteration tree";
 var demoWorkspaceNotes = "Repeatable sample lineage for demos and onboarding. Archive it when reviewing real work.";
 var demoBasePath = ["lineage-demo", "2026-06-lineage-demo"];
+var swissifierManifestPath = join8(repoRoot, "fixtures", defaultProject, "lineage", "swissifier-rich-demo.json");
 var demoAssets = [
   { key: "root", channel: "linkedin", file: "demo-root.svg", label: "Initial Demo Concept", fill: "#f6fbfb", stroke: "#0b7f88" },
   { key: "hookA", channel: "tiktok", file: "demo-hook-a-v01.svg", label: "Hook A v01", fill: "#fff8e6", stroke: "#9a6a00" },
@@ -4556,25 +4576,288 @@ function demoProjectDir(project) {
 function demoRelativePath(project, asset) {
   return join8(...demoBasePath, project, asset.channel, asset.file);
 }
-function demoSeedMediaStatus() {
+function demoFilePath(project, asset) {
+  return join8(demoProjectDir(project), asset.channel, asset.file);
+}
+function swissifierManifest() {
+  return JSON.parse(readFileSync4(swissifierManifestPath, "utf8"));
+}
+function swissifierRelativePath(manifest, asset) {
+  return join8(manifest.media.target_dir, asset.file);
+}
+function swissifierFilePath(manifest, asset) {
+  return join8(repoRoot, ".asset-scratch", swissifierRelativePath(manifest, asset));
+}
+function swissifierSourcePath(manifest, asset, sourceDir) {
+  const direct = join8(sourceDir, asset.file);
+  if (existsSync5(direct)) return direct;
+  const nested = join8(sourceDir, manifest.media.target_dir, asset.file);
+  return existsSync5(nested) ? nested : null;
+}
+function swissifierMediaState(manifest) {
+  const missing = [];
+  const invalid = [];
+  for (const asset of manifest.assets) {
+    const relativePath = swissifierRelativePath(manifest, asset);
+    const path = swissifierFilePath(manifest, asset);
+    if (!existsSync5(path)) {
+      missing.push(relativePath);
+      continue;
+    }
+    if (fileSha256(path) !== asset.checksum_sha256) invalid.push(relativePath);
+  }
+  return { invalid, missing };
+}
+function sha256Hex(input) {
+  return createHash2("sha256").update(input).digest("hex");
+}
+function safeTarEntryName(rawName) {
+  const stripped = rawName.replace(/\0.*$/, "").replace(/^\.\//, "");
+  if (!stripped || stripped === ".") return "";
+  if (stripped.includes("\\") || stripped.startsWith("/") || /^[A-Za-z]:/.test(stripped)) {
+    throw new Error(`Unsafe Swissifier media archive path: ${rawName}`);
+  }
+  const normalized = posix.normalize(stripped);
+  if (!normalized || normalized === "." || normalized.startsWith("../") || normalized === "..") {
+    throw new Error(`Unsafe Swissifier media archive path: ${rawName}`);
+  }
+  return normalized;
+}
+function tarOctal(header, start, length) {
+  const raw = header.toString("utf8", start, start + length).replace(/\0.*$/, "").trim();
+  if (!raw) return 0;
+  if (!/^[0-7]+$/.test(raw)) throw new Error(`Invalid Swissifier media archive size: ${raw}`);
+  return Number.parseInt(raw, 8);
+}
+function tarName(header) {
+  const name = header.toString("utf8", 0, 100).replace(/\0.*$/, "");
+  const prefix = header.toString("utf8", 345, 500).replace(/\0.*$/, "");
+  return prefix ? `${prefix}/${name}` : name;
+}
+function isAppleDoubleEntry(name) {
+  return name === "._." || name.startsWith("._") || name.includes("/._");
+}
+function extractSwissifierMediaArchive(archive, manifest, destination) {
+  const expected = new Map(manifest.assets.map((asset) => [asset.file, asset]));
+  const extracted = /* @__PURE__ */ new Set();
+  const body = gunzipSync(archive);
+  let offset = 0;
+  while (offset + 512 <= body.length) {
+    const header = body.subarray(offset, offset + 512);
+    offset += 512;
+    if (header.every((byte) => byte === 0)) break;
+    const typeflag = header.toString("utf8", 156, 157);
+    const rawName = tarName(header);
+    const name = safeTarEntryName(rawName);
+    const size = tarOctal(header, 124, 12);
+    const nextOffset = offset + Math.ceil(size / 512) * 512;
+    if (nextOffset > body.length) throw new Error(`Truncated Swissifier media archive entry: ${rawName}`);
+    if (!name || typeflag === "5") {
+      offset = nextOffset;
+      continue;
+    }
+    if (typeflag === "x" || typeflag === "g") {
+      offset = nextOffset;
+      continue;
+    }
+    if (isAppleDoubleEntry(name)) {
+      offset = nextOffset;
+      continue;
+    }
+    if (typeflag && typeflag !== "0") throw new Error(`Unsupported Swissifier media archive entry type for ${name}`);
+    const directName = name.startsWith(`${manifest.media.target_dir}/`) ? name.slice(manifest.media.target_dir.length + 1) : name;
+    const asset = expected.get(directName);
+    if (!asset) throw new Error(`Unexpected Swissifier media archive entry: ${name}`);
+    if (size !== asset.size_bytes) throw new Error(`Unexpected Swissifier media archive size for ${name}`);
+    const file = body.subarray(offset, offset + size);
+    const actualSha = sha256Hex(file);
+    if (actualSha !== asset.checksum_sha256) throw new Error(`Checksum mismatch for Swissifier media archive entry: ${name}`);
+    const target = join8(destination, directName);
+    mkdirSync5(dirname3(target), { recursive: true });
+    writeFileSync3(target, file);
+    extracted.add(directName);
+    offset = nextOffset;
+  }
+  const missing = manifest.assets.map((asset) => asset.file).filter((file) => !extracted.has(file));
+  if (missing.length) throw new Error(`Swissifier media archive missing ${missing.length} expected file${missing.length === 1 ? "" : "s"}`);
+  return { extracted: extracted.size };
+}
+async function downloadBuffer(url, maxBytes) {
+  const response = await fetch(url);
+  if (!response.ok) throw new Error(`Swissifier media download failed with HTTP ${response.status}`);
+  const contentLength = Number(response.headers.get("content-length") || 0);
+  if (contentLength > maxBytes) throw new Error(`Swissifier media download is too large: ${contentLength} bytes`);
+  const buffer = Buffer.from(await response.arrayBuffer());
+  if (buffer.length > maxBytes) throw new Error(`Swissifier media download is too large: ${buffer.length} bytes`);
+  return buffer;
+}
+function missingDemoMedia(project) {
+  return demoAssets.filter((asset) => !existsSync5(demoFilePath(project, asset))).map((asset) => demoRelativePath(project, asset));
+}
+function demoSeedMediaStatus(project = defaultProject) {
+  const missing = missingDemoMedia(project);
+  const present = demoAssets.length - missing.length;
   return {
     ok: true,
     media_root: join8(repoRoot, ".asset-scratch"),
-    present: demoAssets.length,
+    present,
     total: demoAssets.length,
-    missing: [],
-    fixture_present: demoAssets.length,
+    missing,
+    fixture_present: present,
     fixture_total: demoAssets.length,
-    fixture_missing: []
+    fixture_missing: missing
   };
 }
-function restoreDemoSeedMedia(fields = { confirmWrite: false }) {
+function swissifierRichDemoMediaStatus(project = defaultProject) {
+  const manifest = swissifierManifest();
+  const { invalid, missing } = swissifierMediaState(manifest);
+  const present = manifest.assets.length - missing.length - invalid.length;
+  return {
+    ok: true,
+    demo_id: manifest.id,
+    project,
+    media_root: join8(repoRoot, ".asset-scratch"),
+    media_target: manifest.media.target_dir,
+    download_available: Boolean(manifest.media.download),
+    download_file: manifest.media.download?.file,
+    download_sha256: manifest.media.download?.sha256,
+    download_url: manifest.media.download?.url,
+    source_env: manifest.media.source_env,
+    source_hint: manifest.media.source_hint,
+    present,
+    total: manifest.assets.length,
+    missing,
+    invalid,
+    fixture_present: present,
+    fixture_total: manifest.assets.length,
+    fixture_missing: [...missing, ...invalid]
+  };
+}
+async function downloadSwissifierRichDemoMedia(project = defaultProject, fields = { confirmWrite: false }) {
+  const manifest = swissifierManifest();
+  const download = manifest.media.download;
+  if (!download) {
+    return {
+      ok: true,
+      demo_id: manifest.id,
+      project,
+      download_available: false,
+      restored: 0,
+      total: manifest.assets.length
+    };
+  }
+  const sourceUrl = fields.sourceUrl || download.url;
+  const expectedSha256 = fields.expectedSha256 || download.sha256;
+  const maxBytes = Math.max(download.size_bytes + 1024 * 1024, download.size_bytes * 1.1);
+  const archive = await downloadBuffer(sourceUrl, maxBytes);
+  const archiveSha256 = sha256Hex(archive);
+  if (archiveSha256 !== expectedSha256) throw new Error(`Swissifier media download checksum mismatch: expected ${expectedSha256}, got ${archiveSha256}`);
+  if (!fields.confirmWrite) {
+    return {
+      ok: true,
+      demo_id: manifest.id,
+      project,
+      dryRun: true,
+      download_available: true,
+      download_file: download.file,
+      download_url: sourceUrl,
+      archive_sha256: archiveSha256,
+      restored: 0,
+      total: manifest.assets.length,
+      would_restore: manifest.assets.length
+    };
+  }
+  const sourceDir = mkdtempSync(join8(tmpdir(), "lineage-swissifier-media-"));
+  try {
+    const extracted = extractSwissifierMediaArchive(archive, manifest, sourceDir);
+    const restored = restoreSwissifierRichDemoMedia(project, { confirmWrite: true, sourceDir });
+    return {
+      ...restored,
+      download_available: true,
+      download_file: download.file,
+      download_url: sourceUrl,
+      archive_sha256: archiveSha256,
+      extracted: extracted.extracted,
+      media_status: swissifierRichDemoMediaStatus(project)
+    };
+  } finally {
+    rmSync(sourceDir, { force: true, recursive: true });
+  }
+}
+function restoreDemoSeedMedia(project = defaultProject, fields = { confirmWrite: false }) {
+  const missing = new Set(missingDemoMedia(project));
+  if (fields.confirmWrite) {
+    for (const asset of demoAssets) {
+      if (missing.has(demoRelativePath(project, asset))) writeDemoFile(project, asset);
+    }
+  }
   return {
     ok: true,
     dryRun: !fields.confirmWrite,
     media_root: join8(repoRoot, ".asset-scratch"),
-    restored: 0,
-    total: demoAssets.length
+    restored: fields.confirmWrite ? missing.size : 0,
+    total: demoAssets.length,
+    would_restore: fields.confirmWrite ? 0 : missing.size,
+    missing: Array.from(missing)
+  };
+}
+function restoreSwissifierRichDemoMedia(project = defaultProject, fields = { confirmWrite: false }) {
+  const manifest = swissifierManifest();
+  const before = swissifierMediaState(manifest);
+  const sourceDir = fields.sourceDir || process.env[manifest.media.source_env];
+  if (!sourceDir) {
+    return {
+      ok: true,
+      demo_id: manifest.id,
+      project,
+      dryRun: !fields.confirmWrite,
+      media_root: join8(repoRoot, ".asset-scratch"),
+      restored: 0,
+      total: manifest.assets.length,
+      would_restore: 0,
+      source_required: true,
+      source_env: manifest.media.source_env,
+      source_hint: manifest.media.source_hint,
+      missing: before.missing,
+      invalid: before.invalid,
+      unavailable: [...before.missing, ...before.invalid]
+    };
+  }
+  const unavailable = [];
+  const copyable = [];
+  const wanted = /* @__PURE__ */ new Set([...before.missing, ...before.invalid]);
+  for (const asset of manifest.assets) {
+    const relativePath = swissifierRelativePath(manifest, asset);
+    if (!wanted.has(relativePath)) continue;
+    const source = swissifierSourcePath(manifest, asset, sourceDir);
+    if (!source || fileSha256(source) !== asset.checksum_sha256) {
+      unavailable.push(relativePath);
+      continue;
+    }
+    copyable.push({ asset, source });
+  }
+  if (fields.confirmWrite) {
+    for (const item of copyable) {
+      const target = swissifierFilePath(manifest, item.asset);
+      mkdirSync5(dirname3(target), { recursive: true });
+      copyFileSync2(item.source, target);
+    }
+  }
+  return {
+    ok: true,
+    demo_id: manifest.id,
+    project,
+    dryRun: !fields.confirmWrite,
+    media_root: join8(repoRoot, ".asset-scratch"),
+    restored: fields.confirmWrite ? copyable.length : 0,
+    total: manifest.assets.length,
+    would_restore: fields.confirmWrite ? 0 : copyable.length,
+    source_required: false,
+    source_env: manifest.media.source_env,
+    source_hint: manifest.media.source_hint,
+    missing: before.missing,
+    invalid: before.invalid,
+    unavailable
   };
 }
 function svg(label, fill, stroke) {
@@ -4592,13 +4875,14 @@ function assetIdFor(asset) {
 function demoAssetIds() {
   return Object.fromEntries(demoAssets.map((asset) => [asset.key, assetIdFor(asset)]));
 }
+function writeDemoFile(project, asset) {
+  const path = demoFilePath(project, asset);
+  mkdirSync5(dirname3(path), { recursive: true });
+  writeFileSync3(path, svg(asset.label, asset.fill, asset.stroke));
+}
 function writeDemoFiles(project) {
   const ids = demoAssetIds();
-  for (const asset of demoAssets) {
-    const path = join8(demoProjectDir(project), asset.channel, asset.file);
-    mkdirSync5(dirname3(path), { recursive: true });
-    writeFileSync3(path, svg(asset.label, asset.fill, asset.stroke));
-  }
+  for (const asset of demoAssets) writeDemoFile(project, asset);
   return ids;
 }
 function upsertDemoAssets(project, ids) {
@@ -4647,6 +4931,55 @@ function upsertDemoAssets(project, ids) {
   }
   return { catalog: 0, local: demoAssets.length, total: demoAssets.length };
 }
+function upsertSwissifierAssets(project, manifest) {
+  const database = lineageDb();
+  const timestamp = nowIso();
+  try {
+    database.prepare(`
+      insert into projects (id, product, catalog_path, created_at, updated_at)
+      values (?, ?, ?, ?, ?)
+      on conflict(id) do update set product = excluded.product, updated_at = excluded.updated_at
+    `).run(project, project, join8(repoRoot, project, "assets", "catalog.json"), timestamp, timestamp);
+    const assetStatement = database.prepare(`
+      insert into assets (
+        id, project_id, source, local_path, s3_key, checksum_sha256, media_type, title, status,
+        channel, campaign, audience, size_bytes, content_type, created_at, updated_at, last_seen_at
+      ) values (?, ?, 'local', ?, null, ?, 'image', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      on conflict(id) do update set
+        project_id = excluded.project_id, source = excluded.source, local_path = excluded.local_path, checksum_sha256 = excluded.checksum_sha256,
+        media_type = excluded.media_type, title = excluded.title, status = excluded.status, channel = excluded.channel,
+        campaign = excluded.campaign, audience = excluded.audience, size_bytes = excluded.size_bytes,
+        content_type = excluded.content_type, updated_at = excluded.updated_at, last_seen_at = excluded.last_seen_at
+    `);
+    const reviewStatement = database.prepare(`
+      insert into asset_reviews (asset_id, review_state, updated_at)
+      values (?, 'unreviewed', ?)
+      on conflict(asset_id) do nothing
+    `);
+    for (const asset of manifest.assets) {
+      assetStatement.run(
+        asset.asset_id,
+        project,
+        swissifierRelativePath(manifest, asset),
+        asset.checksum_sha256,
+        asset.title,
+        asset.status,
+        asset.channel,
+        manifest.campaign,
+        manifest.audience,
+        asset.size_bytes,
+        asset.content_type,
+        timestamp,
+        timestamp,
+        timestamp
+      );
+      reviewStatement.run(asset.asset_id, timestamp);
+    }
+  } finally {
+    database.close();
+  }
+  return { catalog: 0, local: manifest.assets.length, total: manifest.assets.length };
+}
 function seedDemoLineageWorkspace(project, fields) {
   const ids = fields.confirmWrite ? writeDemoFiles(project) : demoAssetIds();
   const rootAssetId = ids.root;
@@ -4692,6 +5025,53 @@ function seedDemoLineageWorkspace(project, fields) {
     workspace
   };
 }
+function seedSwissifierRichDemoWorkspace(project, fields) {
+  const manifest = swissifierManifest();
+  if (!fields.confirmWrite) {
+    return {
+      ok: true,
+      dryRun: true,
+      demo_id: manifest.id,
+      root_asset_id: manifest.root_asset_id,
+      workspace_id: lineageWorkspaceId(project, manifest.root_asset_id),
+      media_status: swissifierRichDemoMediaStatus(project)
+    };
+  }
+  const summary = upsertSwissifierAssets(project, manifest);
+  for (const edge of manifest.edges) {
+    linkLineageAssets(project, { parentAssetId: edge.parent, childAssetId: edge.child, confirmWrite: true });
+  }
+  updateSelectedAsset(project, {
+    assetIds: manifest.selected_asset_ids,
+    confirmWrite: true,
+    maxSelections: manifest.selected_asset_ids.length,
+    notes: "Swissifier rich demo bases selected for the next variation.",
+    rootAssetId: manifest.root_asset_id
+  });
+  updateLineageLayout(project, {
+    confirmWrite: true,
+    rootAssetId: manifest.root_asset_id,
+    positions: manifest.assets.map((asset) => ({ assetId: asset.asset_id, ...asset.position }))
+  });
+  const workspace = createLineageWorkspace(project, {
+    activate: fields.activate !== false,
+    confirmWrite: true,
+    createdBy: "system",
+    notes: manifest.notes,
+    rootAssetId: manifest.root_asset_id,
+    title: manifest.title
+  }).workspace;
+  return {
+    ok: true,
+    message: `Seeded ${manifest.title}`,
+    demo_id: manifest.id,
+    media_status: swissifierRichDemoMediaStatus(project),
+    root_asset_id: manifest.root_asset_id,
+    selected_asset_ids: manifest.selected_asset_ids,
+    summary,
+    workspace
+  };
+}
 function archiveDemoLineageWorkspace(project, confirmWrite) {
   const ids = demoAssetIds();
   const rootAssetId = ids.root;
@@ -4739,11 +5119,37 @@ function registerLineageWorkspaceRoutes(app2, projectFrom2, asyncRoute2) {
   app2.post("/api/lineage-workspaces/demo/archive", asyncRoute2((req, res) => {
     res.json(archiveDemoLineageWorkspace(projectFrom2(req), req.body.confirmWrite === true));
   }));
-  app2.get("/api/lineage-workspaces/demo/media", asyncRoute2((_req, res) => {
-    res.json({ ok: true, status: demoSeedMediaStatus() });
+  app2.post("/api/lineage-workspaces/demo/swissifier/seed", asyncRoute2((req, res) => {
+    res.json(seedSwissifierRichDemoWorkspace(projectFrom2(req), {
+      activate: req.body.activate !== false,
+      confirmWrite: req.body.confirmWrite === true
+    }));
+  }));
+  app2.get("/api/lineage-workspaces/demo/media", asyncRoute2((req, res) => {
+    res.json({ ok: true, status: demoSeedMediaStatus(projectFrom2(req)) });
+  }));
+  app2.get("/api/lineage-workspaces/demo/swissifier/media", asyncRoute2((req, res) => {
+    res.json({ ok: true, status: swissifierRichDemoMediaStatus(projectFrom2(req)) });
   }));
   app2.post("/api/lineage-workspaces/demo/media/restore", asyncRoute2((req, res) => {
-    res.json({ ok: true, result: restoreDemoSeedMedia({ confirmWrite: req.body.confirmWrite === true }) });
+    res.json({ ok: true, result: restoreDemoSeedMedia(projectFrom2(req), { confirmWrite: req.body.confirmWrite === true }) });
+  }));
+  app2.post("/api/lineage-workspaces/demo/swissifier/media/restore", asyncRoute2((req, res) => {
+    res.json({
+      ok: true,
+      result: restoreSwissifierRichDemoMedia(projectFrom2(req), {
+        confirmWrite: req.body.confirmWrite === true,
+        sourceDir: typeof req.body.sourceDir === "string" ? req.body.sourceDir : void 0
+      })
+    });
+  }));
+  app2.post("/api/lineage-workspaces/demo/swissifier/media/download", asyncRoute2(async (req, res) => {
+    res.json({
+      ok: true,
+      result: await downloadSwissifierRichDemoMedia(projectFrom2(req), {
+        confirmWrite: req.body.confirmWrite === true
+      })
+    });
   }));
   app2.get("/api/lineage-workspaces/:workspaceId", asyncRoute2((req, res) => {
     res.json({
@@ -4772,7 +5178,7 @@ function registerLineageWorkspaceRoutes(app2, projectFrom2, asyncRoute2) {
 // src/server.ts
 var app = express2();
 var port = Number(process.env.PORT || 5173);
-var host = process.env.HOST || "127.0.0.1";
+var host = process.env.HOST || "lineage.localhost";
 var isProduction = process.env.NODE_ENV === "production";
 var maxUploadBytes = Number(process.env.LINEAGE_MAX_UPLOAD_MB || 200) * 1024 * 1024;
 var upload = multer({ dest: ensureUploadDir(), limits: { fileSize: maxUploadBytes } });
@@ -5075,7 +5481,7 @@ app.post(
 );
 if (isProduction) {
   const dist = join9(repoRoot, "dist", "web");
-  if (existsSync5(dist)) {
+  if (existsSync6(dist)) {
     app.use(express2.static(dist));
     app.get("*", (_req, res) => res.sendFile(join9(dist, "index.html")));
   }