@pygmalionjs/pygmalion 0.2.38 → 0.2.39

package/dist-lib/testing.js

@@ -1,4 +1,4 @@
-import { F as s, N as a, e as r, s as i, a as t } from "./App-DTeXtV9b.js";
+import { F as s, N as a, e as r, s as i, a as t } from "./App-CJz8NrxS.js";
 export {
   s as FrozenRoutePreviewView,
   a as NodeModel,

package/node/design-session.mjs

@@ -11,6 +11,7 @@ import { normalizeViteMode } from './dev-mirror.mjs';
 import { writeStyleEdit, writeTextEdit } from './inspect-plugin.mjs';
 import { createUnifiedDiff } from './source-diff.mjs';
 import { writeSourceOperations } from './source-operations.mjs';
+import { resolvePygmalionPreviewViteCacheDir } from './preview-vite-cache.mjs';
 
 const execFileAsync = promisify(execFile);
 
@@ -526,6 +527,11 @@ export function pygmalionDesignSessionPlugin(options) {
           PYGMALION_APP_ROOT: sessionAppRoot,
           PYGMALION_VITE_CONFIG: viteConfig,
           PYGMALION_PREVIEW_BASE: `${sessionPreviewPrefix}/`,
+          PYGMALION_VITE_CACHE_DIR: resolvePygmalionPreviewViteCacheDir({
+            appRoot: sessionAppRoot,
+            instance: `session:${session.id}:${session.headSha}`,
+            modulesDirectory: dependencies.modulesDirectory,
+          }),
           PYGMALION_DEV_FRONTEND_ROOT: sessionAppRoot,
           PYGMALION_DEV_BASE: `${sessionPreviewPrefix}/`,
         },

package/node/dev-mirror.mjs

@@ -7,6 +7,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
 import { execFile } from 'node:child_process';
+import { resolvePygmalionPreviewViteCacheDir } from './preview-vite-cache.mjs';
 
 const execFileAsync = promisify(execFile);
 
@@ -864,7 +865,7 @@ export function pygmalionDevMirrorPlugin(options) {
     await run(command, args, { cwd: path.resolve(inventory.cwd ?? editorRoot) });
   };
 
-  const startPreview = async (restart) => {
+  const startPreview = async (restart, sourceIdentity = ref) => {
     if (restart) await stopPreview();
     if (previewChild && previewChild.exitCode == null && previewPort != null) return;
 
@@ -900,6 +901,11 @@ export function pygmalionDevMirrorPlugin(options) {
           PYGMALION_APP_ROOT: mirrorAppRoot,
           PYGMALION_VITE_CONFIG: viteConfig,
           PYGMALION_PREVIEW_BASE: `${prefix}/`,
+          PYGMALION_VITE_CACHE_DIR: resolvePygmalionPreviewViteCacheDir({
+            appRoot: mirrorAppRoot,
+            instance: `mirror:${sourceIdentity}:${prefix}`,
+            modulesDirectory: dependencies.modulesDirectory,
+          }),
           // Legacy names keep older preview configs working.
           PYGMALION_DEV_FRONTEND_ROOT: mirrorAppRoot,
           PYGMALION_DEV_BASE: `${prefix}/`,
@@ -963,7 +969,7 @@ export function pygmalionDevMirrorPlugin(options) {
           await claimDevMirror(repoRoot, mirrorRoot, ownerToken);
           const dependenciesChanged = await syncDependencies();
           await generateInventory(commit);
-          await startPreview(dependenciesChanged);
+          await startPreview(dependenciesChanged, commit);
 
           revision += 1;
           status = {

package/node/dev-view.vite.mjs

@@ -14,6 +14,9 @@ const previewBase =
   process.env.PYGMALION_PREVIEW_BASE ||
   process.env.PYGMALION_DEV_BASE ||
   '/__pygmalion-dev/';
+const previewCacheDir = process.env.PYGMALION_VITE_CACHE_DIR
+  ? path.resolve(process.env.PYGMALION_VITE_CACHE_DIR)
+  : undefined;
 export const PREVIEW_RUNTIME_DEDUPE = ['react', 'react-dom'];
 
 function previewRuntimePlugin() {
@@ -49,6 +52,7 @@ export default defineConfig(async (env) => {
   return mergeConfig(loaded.config, {
     root: appRoot,
     base: previewBase,
+    ...(previewCacheDir ? { cacheDir: previewCacheDir } : {}),
     resolve: {
       // A host config can resolve editor and application dependencies through
       // different package roots. A preview must still run one React dispatcher;

package/node/preview-artifact-store.mjs

@@ -0,0 +1,530 @@
+import { createHash, randomUUID } from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {
+  mergeRoutePreviewArtifactV3,
+  selectRoutePreviewArtifactFrames,
+  validateRoutePreviewArtifactBundle,
+} from './route-preview-artifact-v3.mjs';
+
+export const PYGMALION_PREVIEW_ARTIFACT_STORE_VERSION = 1;
+
+const MANIFEST_ENTRY_LIMIT = 131_072;
+export const PYGMALION_PREVIEW_ARTIFACT_STORE_RETENTION = Object.freeze({
+  revisionsPerNamespace: 16,
+  variantsPerFrame: 32,
+});
+const LOCK_TIMEOUT_MS = 30_000;
+const LOCK_STALE_MS = 120_000;
+const LOCK_POLL_MS = 40;
+const OBJECT_HASH = /^[a-f0-9]{64}$/u;
+
+function sha256(value) {
+  return createHash('sha256').update(value).digest('hex');
+}
+
+function emptyBundle(namespace, sourceRevision) {
+  return {
+    version: 3,
+    namespace,
+    ...(sourceRevision ? { sourceRevision } : {}),
+    assets: { head: {}, stylesheets: {}, screenshots: {} },
+    frames: {},
+  };
+}
+
+function validManifestEntry(entry, kind) {
+  if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return false;
+  if (!OBJECT_HASH.test(entry.object) || !Number.isSafeInteger(entry.generation)) {
+    return false;
+  }
+  if (kind === 'revision') {
+    return typeof entry.sourceRevision === 'string' && entry.sourceRevision.length > 0;
+  }
+  return (
+    typeof entry.id === 'string' &&
+    entry.id.length > 0 &&
+    (entry.fingerprint == null || typeof entry.fingerprint === 'string') &&
+    (entry.sourceRevision == null || typeof entry.sourceRevision === 'string')
+  );
+}
+
+function validateManifest(value, namespace) {
+  if (
+    !value ||
+    typeof value !== 'object' ||
+    Array.isArray(value) ||
+    value.version !== PYGMALION_PREVIEW_ARTIFACT_STORE_VERSION ||
+    value.namespace !== namespace ||
+    !Number.isSafeInteger(value.generation) ||
+    value.generation < 0 ||
+    !Array.isArray(value.revisions) ||
+    !Array.isArray(value.frames) ||
+    value.revisions.length + value.frames.length > MANIFEST_ENTRY_LIMIT ||
+    !value.revisions.every((entry) => validManifestEntry(entry, 'revision')) ||
+    !value.frames.every((entry) => validManifestEntry(entry, 'frame'))
+  ) {
+    throw new Error('Preview artifact store manifest is invalid.');
+  }
+  return value;
+}
+
+async function readJson(file) {
+  return JSON.parse(await fs.readFile(file, 'utf8'));
+}
+
+async function writeJsonAtomic(file, value) {
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  const temporary = `${file}.tmp-${process.pid}-${randomUUID()}`;
+  try {
+    await fs.writeFile(temporary, `${JSON.stringify(value)}\n`, 'utf8');
+    await fs.rename(temporary, file);
+  } catch (error) {
+    await fs.rm(temporary, { force: true }).catch(() => undefined);
+    throw error;
+  }
+}
+
+function processIsAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return null;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === 'ESRCH' ? false : true;
+  }
+}
+
+async function withFilesystemLock(lockPath, task, options = {}) {
+  const timeoutMs = options.lockTimeoutMs ?? LOCK_TIMEOUT_MS;
+  const staleMs = options.lockStaleMs ?? LOCK_STALE_MS;
+  const deadline = Date.now() + timeoutMs;
+  await fs.mkdir(path.dirname(lockPath), { recursive: true });
+  while (true) {
+    try {
+      await fs.mkdir(lockPath);
+      break;
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error;
+      const stale = await fs
+        .stat(lockPath)
+        .then((stat) => Date.now() - stat.mtimeMs > staleMs)
+        .catch(() => false);
+      if (stale) {
+        const ownerState = await readJson(path.join(lockPath, 'owner.json'))
+          .then((owner) => processIsAlive(owner?.pid))
+          .catch(() => null);
+        // A delayed but live writer must never lose its lock: it may resume and
+        // publish a manifest read before another writer. Recover only when the
+        // owning process is confirmed dead, or an old lock never got an owner.
+        if (ownerState === false || ownerState === null) {
+          await fs.rm(lockPath, { recursive: true, force: true });
+          continue;
+        }
+      }
+      if (Date.now() >= deadline) {
+        throw new Error('Timed out waiting for the preview artifact store lock.');
+      }
+      await new Promise((resolve) => setTimeout(resolve, LOCK_POLL_MS));
+    }
+  }
+
+  const owner = path.join(lockPath, 'owner.json');
+  const ownerToken = randomUUID();
+  try {
+    await fs.writeFile(
+      owner,
+      `${JSON.stringify({
+        token: ownerToken,
+        pid: process.pid,
+        createdAt: new Date().toISOString(),
+      })}\n`,
+      'utf8',
+    );
+  } catch (error) {
+    await fs.rm(lockPath, { recursive: true, force: true });
+    throw error;
+  }
+  const heartbeat = setInterval(() => {
+    const now = new Date();
+    void fs.utimes(lockPath, now, now).catch(() => undefined);
+  }, Math.min(2_000, Math.max(100, Math.floor(staleMs / 4))));
+  heartbeat.unref();
+  try {
+    await options.onLockAcquired?.();
+    return await task();
+  } finally {
+    clearInterval(heartbeat);
+    const stillOwned = await readJson(owner)
+      .then((value) => value?.token === ownerToken)
+      .catch(() => false);
+    if (stillOwned) {
+      await fs.rm(lockPath, { recursive: true, force: true });
+    }
+  }
+}
+
+function upsertRevision(entries, next) {
+  return [
+    ...entries.filter((entry) => entry.sourceRevision !== next.sourceRevision),
+    next,
+  ]
+    .sort((a, b) => b.generation - a.generation)
+    .slice(
+      0,
+      PYGMALION_PREVIEW_ARTIFACT_STORE_RETENTION.revisionsPerNamespace,
+    );
+}
+
+function upsertFrame(entries, next) {
+  const updated = [
+    ...entries.filter(
+      (entry) =>
+        entry.id !== next.id ||
+        entry.fingerprint !== next.fingerprint ||
+        (next.fingerprint == null &&
+          entry.sourceRevision !== next.sourceRevision),
+    ),
+    next,
+  ];
+  const keptForFrame = new Set(
+    updated
+      .filter((entry) => entry.id === next.id)
+      .sort((a, b) => b.generation - a.generation)
+      .slice(0, PYGMALION_PREVIEW_ARTIFACT_STORE_RETENTION.variantsPerFrame),
+  );
+  return updated.filter(
+    (entry) => entry.id !== next.id || keptForFrame.has(entry),
+  );
+}
+
+/** The persistent sharded store derived from the compatible artifactFile path. */
+export function resolvePreviewArtifactStoreDirectory(artifactFile) {
+  return `${path.resolve(artifactFile)}.store`;
+}
+
+export function createPreviewArtifactStore({
+  artifactFile,
+  storeDirectory = resolvePreviewArtifactStoreDirectory(artifactFile),
+  lockTimeoutMs,
+  lockStaleMs,
+  onLockAcquired,
+} = {}) {
+  if (typeof artifactFile !== 'string' || !artifactFile.trim()) {
+    throw new TypeError('Preview artifact store requires an artifact file.');
+  }
+  const legacyFile = path.resolve(artifactFile);
+  const root = path.resolve(storeDirectory);
+  let legacyCache = null;
+
+  const namespaceHash = (namespace) => sha256(namespace);
+  const manifestPath = (namespace) =>
+    path.join(root, 'namespaces', `${namespaceHash(namespace)}.json`);
+  const lockPath = (namespace) =>
+    path.join(root, 'locks', `${namespaceHash(namespace)}.lock`);
+  const objectPath = (hash) =>
+    path.join(root, 'objects', hash.slice(0, 2), `${hash}.json`);
+
+  const readManifest = async (namespace) => {
+    try {
+      return validateManifest(await readJson(manifestPath(namespace)), namespace);
+    } catch (error) {
+      if (error?.code === 'ENOENT') return null;
+      throw error;
+    }
+  };
+
+  const writeObject = async (artifact) => {
+    const validation = validateRoutePreviewArtifactBundle(artifact);
+    if (!validation.valid) {
+      throw new Error('Preview artifact store refused an invalid artifact.');
+    }
+    const serialized = JSON.stringify(artifact);
+    const hash = sha256(serialized);
+    const target = objectPath(hash);
+    try {
+      await fs.access(target);
+      return hash;
+    } catch {
+      await writeJsonAtomic(target, artifact);
+      return hash;
+    }
+  };
+
+  const readObject = async (hash) => {
+    if (!OBJECT_HASH.test(hash)) return null;
+    try {
+      const raw = await fs.readFile(objectPath(hash), 'utf8');
+      const artifact = JSON.parse(raw);
+      if (sha256(JSON.stringify(artifact)) !== hash) return null;
+      return validateRoutePreviewArtifactBundle(artifact).valid ? artifact : null;
+    } catch {
+      return null;
+    }
+  };
+
+  const materializeManifest = async (manifest, sourceRevision) => {
+    const latestById = new Map();
+    for (const entry of manifest.frames) {
+      const current = latestById.get(entry.id);
+      if (!current || current.generation < entry.generation) {
+        latestById.set(entry.id, entry);
+      }
+    }
+    let aggregate = null;
+    for (const entry of [...latestById.values()].sort((a, b) =>
+      a.id.localeCompare(b.id),
+    )) {
+      const artifact = await readObject(entry.object);
+      if (!artifact || artifact.version !== 3 || artifact.namespace !== manifest.namespace) {
+        continue;
+      }
+      aggregate = mergeRoutePreviewArtifactV3(aggregate, artifact);
+    }
+    if (!aggregate) return null;
+    const { sourceRevision: _mixedRevision, ...withoutRevision } = aggregate;
+    return {
+      ...withoutRevision,
+      ...(sourceRevision ? { sourceRevision } : {}),
+    };
+  };
+
+  const publishArtifact = async (
+    artifact,
+    {
+      recordRevision = true,
+      sourceRevision = artifact?.sourceRevision,
+      materializeLegacy = true,
+    } = {},
+  ) => {
+    const validation = validateRoutePreviewArtifactBundle(artifact);
+    if (!validation.valid || typeof artifact.namespace !== 'string') {
+      throw new Error('Preview artifact store refused an invalid artifact.');
+    }
+    if (
+      recordRevision &&
+      sourceRevision &&
+      artifact.sourceRevision !== sourceRevision
+    ) {
+      throw new Error('Preview artifact store refused a mismatched revision.');
+    }
+    const namespace = artifact.namespace;
+    return withFilesystemLock(
+      lockPath(namespace),
+      async () => {
+        // Cross-process correctness depends on this read happening after the
+        // lock is held. Every writer merges its entries into the newest manifest.
+        const stored = await readManifest(namespace);
+        const generation = (stored?.generation ?? 0) + 1;
+        let manifest = stored ?? {
+          version: PYGMALION_PREVIEW_ARTIFACT_STORE_VERSION,
+          namespace,
+          generation: 0,
+          revisions: [],
+          frames: [],
+        };
+        const previousObjectReferences = new Set(
+          [
+            ...(stored?.revisions ?? []),
+            ...(stored?.frames ?? []),
+          ].map((entry) => entry.object),
+        );
+        if (recordRevision && sourceRevision) {
+          const wholeObject = await writeObject(artifact);
+          const nextRevision = {
+            sourceRevision,
+            object: wholeObject,
+            generation,
+          };
+          const alreadyRecorded = manifest.revisions.some(
+            (entry) =>
+              entry.sourceRevision === nextRevision.sourceRevision &&
+              entry.object === nextRevision.object,
+          );
+          if (!alreadyRecorded) {
+            manifest = {
+              ...manifest,
+              revisions: upsertRevision(manifest.revisions, nextRevision),
+            };
+          }
+        }
+        if (artifact.version === 3) {
+          let frames = manifest.frames;
+          for (const [id, frame] of Object.entries(artifact.frames)) {
+            const selected = selectRoutePreviewArtifactFrames(artifact, [{ id }]);
+            const object = await writeObject(selected.bundle);
+            const nextFrame = {
+              id,
+              fingerprint:
+                typeof frame.fingerprint === 'string' ? frame.fingerprint : null,
+              sourceRevision: sourceRevision ?? null,
+              object,
+              generation,
+            };
+            const alreadyRecorded = frames.some(
+              (entry) =>
+                entry.id === nextFrame.id &&
+                entry.fingerprint === nextFrame.fingerprint &&
+                entry.sourceRevision === nextFrame.sourceRevision &&
+                entry.object === nextFrame.object,
+            );
+            if (!alreadyRecorded) frames = upsertFrame(frames, nextFrame);
+          }
+          manifest = { ...manifest, frames };
+        }
+        manifest = { ...manifest, generation };
+        if (
+          manifest.revisions.length + manifest.frames.length >
+          MANIFEST_ENTRY_LIMIT
+        ) {
+          throw new Error('Preview artifact store manifest is too large.');
+        }
+        await writeJsonAtomic(manifestPath(namespace), manifest);
+
+        // Objects contain the namespace, so an identical hash cannot be owned
+        // by another namespace. Under this namespace lock it is safe to remove
+        // entries retention just made unreachable, after the manifest commit.
+        const retainedObjectReferences = new Set(
+          [...manifest.revisions, ...manifest.frames].map(
+            (entry) => entry.object,
+          ),
+        );
+        await Promise.all(
+          [...previousObjectReferences]
+            .filter((hash) => !retainedObjectReferences.has(hash))
+            .map((hash) => fs.rm(objectPath(hash), { force: true })),
+        );
+
+        if (materializeLegacy) {
+          // Never stamp a cross-revision frame aggregate with the current
+          // revision. The compatibility file remains an honest exact snapshot;
+          // endpoint frame selection is served from the manifest above.
+          let materialized = recordRevision ? artifact : null;
+          if (artifact.version === 3 && !recordRevision) {
+            const exactRevision =
+              manifest.revisions.find(
+                (entry) => entry.sourceRevision === sourceRevision,
+              ) ??
+              [...manifest.revisions].sort(
+                (a, b) => b.generation - a.generation,
+              )[0];
+            materialized = exactRevision
+              ? await readObject(exactRevision.object)
+              : null;
+          }
+          // A partial frame capture is never written as a whole revision. If no
+          // exact revision exists yet, leave the compatibility file untouched.
+          if (materialized) {
+            await writeJsonAtomic(legacyFile, materialized);
+            legacyCache = {
+              hash: sha256(JSON.stringify(materialized)),
+              status: 'valid',
+              artifact: materialized,
+            };
+          }
+        }
+        return artifact;
+      },
+      { lockTimeoutMs, lockStaleMs, onLockAcquired },
+    );
+  };
+
+  const importLegacyArtifact = async () => {
+    let raw;
+    try {
+      raw = await fs.readFile(legacyFile, 'utf8');
+    } catch (error) {
+      if (error?.code === 'ENOENT') return { status: 'missing', artifact: null };
+      throw error;
+    }
+    let artifact;
+    try {
+      artifact = JSON.parse(raw);
+    } catch {
+      return { status: 'invalid', artifact: null };
+    }
+    const hash = sha256(JSON.stringify(artifact));
+    if (legacyCache?.hash === hash) return legacyCache;
+    if (!validateRoutePreviewArtifactBundle(artifact).valid) {
+      legacyCache = { hash, status: 'invalid', artifact: null };
+      return legacyCache;
+    }
+    // The compatibility contract treats this file as one exact snapshot. Frame
+    // consumers still decide exactness from their requested fingerprints; the
+    // idempotent entries below ensure restarting Vite cannot promote this seed
+    // above a newer partial capture merely by importing it again.
+    await publishArtifact(artifact, { materializeLegacy: false });
+    legacyCache = { hash, status: 'valid', artifact };
+    return legacyCache;
+  };
+
+  const readExactArtifact = async (namespace, sourceRevision) => {
+    const manifest = await readManifest(namespace);
+    const entry = manifest?.revisions.find(
+      (candidate) => candidate.sourceRevision === sourceRevision,
+    );
+    if (!entry) return null;
+    const artifact = await readObject(entry.object);
+    return artifact?.namespace === namespace &&
+      artifact.sourceRevision === sourceRevision
+      ? artifact
+      : null;
+  };
+
+  const readLatestArtifact = async (namespace) => {
+    const manifest = await readManifest(namespace);
+    if (!manifest) return null;
+    const revision = [...manifest.revisions].sort(
+      (a, b) => b.generation - a.generation,
+    )[0];
+    if (revision) {
+      const artifact = await readObject(revision.object);
+      if (artifact?.namespace === namespace) return artifact;
+    }
+    return materializeManifest(manifest);
+  };
+
+  const readFrameSelection = async (namespace, sourceRevision, wanted) => {
+    const manifest = await readManifest(namespace);
+    let aggregate = null;
+    if (manifest) {
+      for (const request of wanted) {
+        const candidates = manifest.frames
+          .filter((entry) => entry.id === request.id)
+          .sort((a, b) => b.generation - a.generation);
+        const exact = candidates.filter((entry) =>
+          request.fingerprint != null
+            ? entry.fingerprint === request.fingerprint
+            : entry.sourceRevision === sourceRevision,
+        );
+        const ordered = [...exact, ...candidates.filter((entry) => !exact.includes(entry))];
+        for (const entry of ordered) {
+          const artifact = await readObject(entry.object);
+          if (
+            artifact?.version === 3 &&
+            artifact.namespace === namespace &&
+            artifact.frames[request.id]
+          ) {
+            aggregate = mergeRoutePreviewArtifactV3(aggregate, artifact);
+            break;
+          }
+        }
+      }
+    }
+    return selectRoutePreviewArtifactFrames(
+      aggregate ?? emptyBundle(namespace, sourceRevision),
+      wanted,
+      { includeStale: true },
+    );
+  };
+
+  return {
+    artifactFile: legacyFile,
+    storeDirectory: root,
+    importLegacyArtifact,
+    publishArtifact,
+    readExactArtifact,
+    readFrameSelection,
+    readLatestArtifact,
+  };
+}

package/node/preview-vite-cache.mjs

@@ -0,0 +1,26 @@
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+
+/** Returns a stable, isolated Vite optimizeDeps cache for one preview instance. */
+export function resolvePygmalionPreviewViteCacheDir({
+  appRoot,
+  instance,
+  modulesDirectory = 'node_modules',
+}) {
+  if (typeof appRoot !== 'string' || !appRoot.trim()) {
+    throw new TypeError('Preview Vite cache requires an app root.');
+  }
+  if (typeof instance !== 'string' || !instance.trim()) {
+    throw new TypeError('Preview Vite cache requires an instance identity.');
+  }
+  const resolvedRoot = path.resolve(appRoot);
+  const digest = createHash('sha256')
+    .update(`${resolvedRoot}\u0000${instance}`)
+    .digest('hex')
+    .slice(0, 20);
+  return path.join(
+    path.resolve(resolvedRoot, modulesDirectory),
+    '.vite-pygmalion',
+    digest,
+  );
+}