@playcraft/cli 0.1.38-beta → 0.1.39-prod

package/dist/workspace-runtime/workspaces/artifact-events.js

@@ -1,55 +0,0 @@
-import { PLATFORM_ROUTES, platformEndpoint } from '@playcraft/common/cloud-workspace/runtime';
-import { workspaceRoot } from './registry.js';
-import { WorkspaceArtifactStore } from './artifacts.js';
-export async function refreshWorkspaceArtifacts(state, workspaceId, origin) {
-    if (state.journal.destroyed())
-        throw new Error('runtime_destroyed');
-    const root = await workspaceRoot(state, workspaceId);
-    const result = await new WorkspaceArtifactStore(state.config.stateDir, workspaceId).discover(root, origin?.source, origin?.paths);
-    if (result.changed && !state.journal.destroyed()) {
-        const event = await state.journal.allocateSourceEvent({
-            runtimeId: state.config.runtimeId, generation: state.config.generation, runtimeEpoch: state.runtimeEpoch,
-            workspaceId, type: 'artifact.updated', occurredAt: result.list.scannedAt,
-            payload: { workspaceId, artifacts: result.list.artifacts.map(artifact => ({ id: artifact.id, currentVersionId: artifact.currentVersionId })) },
-        });
-        // The durable source stream remains authoritative when the callback is temporarily unavailable.
-        void fetch(platformEndpoint(state.config.publicBaseUrl, PLATFORM_ROUTES.events), {
-            method: 'POST', signal: AbortSignal.timeout(5000),
-            headers: { authorization: `Bearer ${state.config.controlToken}`, 'x-playcraft-control-token': state.config.controlToken, 'content-type': 'application/json' },
-            body: JSON.stringify({ runtimeId: state.config.runtimeId, generation: state.config.generation, runtimeEpoch: state.runtimeEpoch, events: [event] }),
-        }).then(response => response.body?.cancel()).catch(() => undefined);
-    }
-    return result.list;
-}
-/** Completed commands and turns reconcile outputs, including work done before a failed turn. */
-export function observeWorkspaceArtifacts(state) {
-    const pending = new Map();
-    const running = new Set();
-    const reconcile = (workspaceId) => {
-        const task = refreshWorkspaceArtifacts(state, workspaceId).catch(() => undefined);
-        running.add(task);
-        void task.finally(() => running.delete(task));
-    };
-    const stop = state.journal.onSourceEvent((event) => {
-        if (!['file.written', 'files.changed', 'filesystem.changed', 'item/completed', 'turn.completed', 'turn/completed', 'turn.failed', 'turn.interrupted'].includes(event.type))
-            return;
-        const payload = event.payload && typeof event.payload === 'object' ? event.payload : {};
-        const sessionId = typeof payload.sessionId === 'string' ? payload.sessionId : undefined;
-        const workspaceId = typeof payload.workspaceId === 'string' ? payload.workspaceId : sessionId ? state.journal.getSession(sessionId)?.workspaceId : undefined;
-        if (!workspaceId)
-            return;
-        const timer = pending.get(workspaceId);
-        if (timer)
-            clearTimeout(timer);
-        pending.set(workspaceId, setTimeout(() => { pending.delete(workspaceId); reconcile(workspaceId); }, 200));
-    });
-    return async () => {
-        stop();
-        for (const [workspaceId, timer] of pending) {
-            clearTimeout(timer);
-            reconcile(workspaceId);
-        }
-        pending.clear();
-        await Promise.all([...running]);
-    };
-}

package/dist/workspace-runtime/workspaces/artifact-files.js

@@ -1,197 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { constants } from 'node:fs';
-import { lstat, mkdir, open, readFile, realpath, link, unlink } from 'node:fs/promises';
-import { extname, join, posix, resolve, sep } from 'node:path';
-import { WORKSPACE_ARTIFACT_MAX_BYTES, isWorkspaceArtifactOutputPath, workspaceRelativePathSchema } from '@playcraft/common/cloud-workspace/runtime';
-const formats = {
-    '.png': ['image', 'image/png'], '.jpg': ['image', 'image/jpeg'], '.jpeg': ['image', 'image/jpeg'],
-    '.webp': ['image', 'image/webp'], '.gif': ['image', 'image/gif'], '.avif': ['image', 'image/avif'], '.svg': ['image', 'image/svg+xml'],
-    '.mp4': ['video', 'video/mp4'], '.webm': ['video', 'video/webm'], '.mov': ['video', 'video/quicktime'],
-    '.mp3': ['audio', 'audio/mpeg'], '.wav': ['audio', 'audio/wav'], '.ogg': ['audio', 'audio/ogg'], '.m4a': ['audio', 'audio/mp4'], '.flac': ['audio', 'audio/flac'],
-    '.glb': ['model', 'model/gltf-binary'], '.gltf': ['model', 'model/gltf+json'], '.obj': ['model', 'text/plain'], '.fbx': ['model', 'application/octet-stream'], '.stl': ['model', 'model/stl'], '.usdz': ['model', 'model/vnd.usdz+zip'],
-    '.md': ['document', 'text/markdown'], '.txt': ['document', 'text/plain'], '.pdf': ['document', 'application/pdf'],
-    '.html': ['document', 'text/html'], '.csv': ['document', 'text/csv'], '.docx': ['document', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'],
-    '.pptx': ['document', 'application/vnd.openxmlformats-officedocument.presentationml.presentation'], '.xlsx': ['document', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
-    '.zip': ['file', 'application/zip'],
-};
-export function artifactFormat(path) { return formats[extname(path).toLowerCase()]; }
-export function artifactMime(path) { return artifactFormat(path)?.[1] ?? 'application/octet-stream'; }
-/** Reject every redirected path segment, including links that happen to remain in the workspace. */
-export async function artifactPath(root, path) {
-    const parsed = workspaceRelativePathSchema.safeParse(path);
-    if (!parsed.success)
-        throw new Error('invalid_artifact_path');
-    const actualRoot = await realpath(root);
-    let target = actualRoot;
-    for (const part of parsed.data.split('/')) {
-        target = join(target, part);
-        if ((await lstat(target)).isSymbolicLink())
-            throw new Error('invalid_artifact_path');
-    }
-    if (!(await realpath(target)).startsWith(`${actualRoot}${sep}`))
-        throw new Error('invalid_artifact_path');
-    return target;
-}
-export async function artifactDirectory(root, relative) {
-    let target = await realpath(root);
-    for (const part of workspaceRelativePathSchema.parse(relative).split('/')) {
-        target = join(target, part);
-        await mkdir(target, { mode: 0o700 }).catch(error => { if (error.code !== 'EEXIST')
-            throw error; });
-        const stat = await lstat(target);
-        if (!stat.isDirectory() || stat.isSymbolicLink())
-            throw new Error('invalid_artifact_directory');
-    }
-    return target;
-}
-/** Copies the exact bytes observed, and refuses a file changed while being copied. */
-export async function snapshotArtifactFile(root, path, objects, role = 'primary') {
-    const target = await artifactPath(root, path);
-    const source = await open(target, constants.O_RDONLY | constants.O_NOFOLLOW);
-    const temporary = join(objects, `${randomUUID()}.tmp`);
-    let output;
-    try {
-        const before = await source.stat();
-        if (!before.isFile() || before.nlink !== 1 || before.size > WORKSPACE_ARTIFACT_MAX_BYTES)
-            throw new Error('artifact_file_unavailable');
-        output = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
-        const hash = createHash('sha256'), buffer = Buffer.allocUnsafe(64 * 1024);
-        let size = 0;
-        for (;;) {
-            const { bytesRead } = await source.read(buffer, 0, buffer.length, size);
-            if (!bytesRead)
-                break;
-            size += bytesRead;
-            if (size > WORKSPACE_ARTIFACT_MAX_BYTES)
-                throw new Error('artifact_file_unavailable');
-            const chunk = buffer.subarray(0, bytesRead);
-            hash.update(chunk);
-            let written = 0;
-            while (written < bytesRead)
-                written += (await output.write(chunk, written, bytesRead - written)).bytesWritten;
-        }
-        const after = await source.stat();
-        if (before.size !== size || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs)
-            throw new Error('artifact_file_changed');
-        await output.sync();
-        await output.close();
-        output = undefined;
-        const sha256 = hash.digest('hex');
-        await link(temporary, join(objects, sha256)).catch(async (error) => {
-            if (error.code !== 'EEXIST')
-                throw error;
-            const existing = await open(join(objects, sha256), constants.O_RDONLY | constants.O_NOFOLLOW);
-            try {
-                if (!(await existing.stat()).isFile() || (await existing.stat()).size !== size)
-                    throw new Error('artifact_snapshot_invalid');
-            }
-            finally {
-                await existing.close();
-            }
-        });
-        return { path, size, sha256, mimeType: artifactMime(path), role };
-    }
-    finally {
-        await source.close();
-        await output?.close();
-        await unlink(temporary).catch(error => { if (error.code !== 'ENOENT')
-            throw error; });
-    }
-}
-function resourcePath(primary, uri) {
-    if (uri.startsWith('data:'))
-        return undefined;
-    if (/^[a-z][a-z\d+.-]*:/i.test(uri) || uri.startsWith('/') || uri.includes('\\') || uri.includes('?') || uri.includes('#'))
-        throw new Error('invalid_artifact_resource');
-    const decoded = decodeURIComponent(uri);
-    const path = posix.normalize(posix.join(posix.dirname(primary), decoded));
-    if (!isWorkspaceArtifactOutputPath(path) || path.split('/').some(part => part.startsWith('.')))
-        throw new Error('invalid_artifact_resource');
-    return path;
-}
-async function smallText(root, path) {
-    const target = await artifactPath(root, path);
-    if ((await lstat(target)).size > 8 * 1024 * 1024)
-        throw new Error('artifact_metadata_too_large');
-    return readFile(target, 'utf8');
-}
-async function binaryModelDocument(root, path) {
-    const handle = await open(await artifactPath(root, path), constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        const header = Buffer.alloc(20);
-        const read = await handle.read(header, 0, header.length, 0);
-        if (read.bytesRead < 20 || header.readUInt32LE(0) !== 0x46546c67)
-            return undefined;
-        const size = (await handle.stat()).size, length = header.readUInt32LE(12);
-        if (header.readUInt32LE(4) !== 2 || header.readUInt32LE(8) !== size || header.readUInt32LE(16) !== 0x4e4f534a
-            || length < 2 || length > 8 * 1024 * 1024 || length + 20 > size)
-            throw new Error('artifact_model_invalid');
-        const bytes = Buffer.alloc(length);
-        let offset = 0;
-        while (offset < length) {
-            const part = await handle.read(bytes, offset, length - offset, 20 + offset);
-            if (!part.bytesRead)
-                throw new Error('artifact_model_invalid');
-            offset += part.bytesRead;
-        }
-        return JSON.parse(bytes.toString('utf8').replace(/\0+$/, ''));
-    }
-    finally {
-        await handle.close();
-    }
-}
-/** Only explicit model references become members; neighboring names never imply a relationship. */
-export async function artifactResources(root, path) {
-    const resources = new Set();
-    const add = (from, uri) => { const result = resourcePath(from, uri); if (result)
-        resources.add(result); };
-    const extension = extname(path).toLowerCase();
-    if (extension === '.gltf' || extension === '.glb') {
-        const body = (extension === '.gltf' ? JSON.parse(await smallText(root, path)) : await binaryModelDocument(root, path));
-        if (body)
-            for (const resource of [...(body.buffers ?? []), ...(body.images ?? [])])
-                if (typeof resource.uri === 'string')
-                    add(path, resource.uri);
-    }
-    else if (extname(path).toLowerCase() === '.obj') {
-        for (const line of (await smallText(root, path)).split(/\r?\n/)) {
-            const material = /^\s*mtllib\s+(.+?)\s*$/.exec(line)?.[1];
-            if (material)
-                add(path, material);
-        }
-        for (const material of [...resources]) {
-            for (const line of (await smallText(root, material)).split(/\r?\n/)) {
-                const texture = /^\s*(?:map_\w+|bump|disp|decal|norm)\s+(\S.*?)\s*$/.exec(line)?.[1];
-                // Options require a material parser; do not guess the filename from an option list.
-                if (texture && !texture.startsWith('-'))
-                    add(material, texture);
-            }
-        }
-    }
-    if (resources.size > 255)
-        throw new Error('artifact_too_many_resources');
-    return [...resources].sort();
-}
-export async function snapshotArtifactBundle(root, path, objects, thumbnailPath) {
-    if (!isWorkspaceArtifactOutputPath(path) || (thumbnailPath !== undefined && !isWorkspaceArtifactOutputPath(thumbnailPath)))
-        throw new Error('invalid_artifact_path');
-    const resources = await artifactResources(root, path);
-    const files = [await snapshotArtifactFile(root, path, objects)];
-    for (const resource of resources)
-        if (resource !== path)
-            files.push(await snapshotArtifactFile(root, resource, objects, 'resource'));
-    if (thumbnailPath && !files.some(file => file.path === thumbnailPath))
-        files.push(await snapshotArtifactFile(root, thumbnailPath, objects, 'thumbnail'));
-    if (files.reduce((size, file) => size + file.size, 0) > WORKSPACE_ARTIFACT_MAX_BYTES)
-        throw new Error('artifact_bundle_too_large');
-    return files;
-}
-export function artifactBundleDigest(files) {
-    return createHash('sha256').update(JSON.stringify([...files].sort((a, b) => a.path.localeCompare(b.path)).map(file => [file.path, file.sha256, file.role]))).digest('hex');
-}
-export function relativeArtifactPath(root, path) {
-    const target = resolve(path), prefix = `${resolve(root)}${sep}`;
-    if (!target.startsWith(prefix))
-        throw new Error('invalid_artifact_path');
-    return workspaceRelativePathSchema.parse(target.slice(prefix.length).split(sep).join('/'));
-}

package/dist/workspace-runtime/workspaces/artifact-receipts.js

@@ -1,89 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { constants } from 'node:fs';
-import { lstat, open, rename, unlink } from 'node:fs/promises';
-import { dirname, join, resolve } from 'node:path';
-import { isWorkspaceArtifactOutputPath, workspaceArtifactReceiptSchema } from '@playcraft/common/cloud-workspace/runtime';
-import { artifactDirectory, artifactFormat, relativeArtifactPath, snapshotArtifactBundle } from './artifact-files.js';
-import { excludeFromGit } from './dependencies.js';
-export const ARTIFACT_RECEIPTS_DIRECTORY = '.playcraft/artifact-receipts';
-export const artifactReceiptSchema = workspaceArtifactReceiptSchema;
-async function generatedWorkspace(cwd) {
-    for (let root = resolve(cwd);; root = dirname(root)) {
-        const file = join(root, '.playcraft/workspace-context.json');
-        try {
-            const handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
-            try {
-                if ((await handle.stat()).size > 8192)
-                    throw new Error('invalid_workspace_context');
-                const value = JSON.parse(await handle.readFile('utf8'));
-                if (value.schemaVersion !== 'playcraft.workspace-context.v1' || typeof value.workspaceId !== 'string')
-                    throw new Error('invalid_workspace_context');
-                return { root, workspaceId: value.workspaceId };
-            }
-            finally {
-                await handle.close();
-            }
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
-        }
-        if (dirname(root) === root)
-            return undefined;
-    }
-}
-/** Preserve final outputs before another command overwrites them; intermediate project assets are not registered. */
-export async function captureGeneratedArtifact(output, tool, metadata = {}, cwd = process.cwd()) {
-    const context = await generatedWorkspace(cwd);
-    if (!context)
-        return;
-    const absolute = resolve(cwd, output);
-    let path;
-    try {
-        path = relativeArtifactPath(context.root, absolute);
-    }
-    catch {
-        return;
-    }
-    if (!isWorkspaceArtifactOutputPath(path) || !artifactFormat(path))
-        return;
-    const receipts = await artifactDirectory(context.root, ARTIFACT_RECEIPTS_DIRECTORY);
-    const objects = await artifactDirectory(context.root, `${ARTIFACT_RECEIPTS_DIRECTORY}/objects`);
-    const thumbnailPath = metadata.thumbnailPath ? relativeArtifactPath(context.root, resolve(cwd, metadata.thumbnailPath)) : undefined;
-    const files = await snapshotArtifactBundle(context.root, path, objects, thumbnailPath);
-    const receipt = artifactReceiptSchema.parse({
-        id: randomUUID(), workspaceId: context.workspaceId, path,
-        source: { kind: 'generated', tool, generatedAt: new Date().toISOString() }, files,
-        ...(metadata.width ? { width: metadata.width } : {}), ...(metadata.height ? { height: metadata.height } : {}),
-        ...(metadata.duration !== undefined ? { duration: metadata.duration } : {}),
-    });
-    const temporary = join(receipts, `${receipt.id}.tmp`);
-    const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
-    try {
-        await handle.writeFile(`${JSON.stringify(receipt)}\n`);
-        await handle.sync();
-        await handle.close();
-        await rename(temporary, join(receipts, `${receipt.id}.json`));
-        // The workspace checkpoint retains these receipts; they are not source files or exported assets.
-        await excludeFromGit(context.root, `/${ARTIFACT_RECEIPTS_DIRECTORY}/`);
-    }
-    finally {
-        await handle.close();
-        await unlink(temporary).catch(error => { if (error.code !== 'ENOENT')
-            throw error; });
-    }
-}
-export async function readArtifactReceipt(path) {
-    if (!(await lstat(path)).isFile())
-        throw new Error('invalid_artifact_receipt');
-    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        const stat = await handle.stat();
-        if (!stat.isFile() || stat.nlink !== 1 || stat.size > 1024 * 1024)
-            throw new Error('invalid_artifact_receipt');
-        return artifactReceiptSchema.parse(JSON.parse(await handle.readFile('utf8')));
-    }
-    finally {
-        await handle.close();
-    }
-}

package/dist/workspace-runtime/workspaces/artifacts.js

@@ -1,282 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { constants } from 'node:fs';
-import { lstat, mkdir, open, readdir, rename, unlink } from 'node:fs/promises';
-import { basename, join } from 'node:path';
-import sharp from 'sharp';
-import { WORKSPACE_ARTIFACT_OUTPUT_DIRECTORY, isWorkspaceArtifactOutputPath, isWorkspaceArtifactOutputVersion, workspaceArtifactContentQuerySchema, workspaceArtifactListSchema, } from '@playcraft/common/cloud-workspace/runtime';
-import { artifactBundleDigest, artifactDirectory, artifactFormat, artifactPath, artifactResources, snapshotArtifactBundle, snapshotArtifactFile } from './artifact-files.js';
-import { ARTIFACT_RECEIPTS_DIRECTORY, readArtifactReceipt } from './artifact-receipts.js';
-const serial = new Map();
-function digest(text) { return createHash('sha256').update(text).digest('hex'); }
-function artifactId(workspaceId, path) { return `artifact_${digest(`${workspaceId}\0${path}`).slice(0, 40)}`; }
-function outputArtifacts(artifacts) {
-    return artifacts.flatMap(artifact => {
-        const versions = artifact.versions.filter(isWorkspaceArtifactOutputVersion);
-        if (!versions.length)
-            return [];
-        const current = versions.find(version => version.id === artifact.currentVersionId)
-            ?? versions.reduce((latest, version) => version.createdAt > latest.createdAt ? version : latest);
-        return [{ ...artifact, versions, currentVersionId: current.id, updatedAt: current.createdAt }];
-    }).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt) || a.id.localeCompare(b.id));
-}
-/** Catalogs and immutable bytes are control-owned, outside the mutable checkout. */
-export class WorkspaceArtifactStore {
-    stateDir;
-    workspaceId;
-    constructor(stateDir, workspaceId) {
-        this.stateDir = stateDir;
-        this.workspaceId = workspaceId;
-    }
-    async directory() {
-        await mkdir(this.stateDir, { recursive: true, mode: 0o700 });
-        return artifactDirectory(this.stateDir, `artifacts/${digest(this.workspaceId)}`);
-    }
-    async read(directory) {
-        const handle = await open(join(directory, 'catalog.json'), constants.O_RDONLY | constants.O_NOFOLLOW).catch(error => {
-            if (error.code === 'ENOENT')
-                return undefined;
-            throw error;
-        });
-        if (!handle)
-            return { artifacts: [], scannedAt: new Date().toISOString(), receipts: [], observations: {} };
-        try {
-            const stat = await handle.stat();
-            if (!stat.isFile() || stat.size > 32 * 1024 * 1024)
-                throw new Error('artifact_catalog_invalid');
-            const { receipts, observations = {}, ...body } = JSON.parse(await handle.readFile('utf8'));
-            if (!Array.isArray(receipts) || receipts.some(id => typeof id !== 'string'))
-                throw new Error('artifact_catalog_invalid');
-            return { ...workspaceArtifactListSchema.parse(body), receipts, observations };
-        }
-        finally {
-            await handle.close();
-        }
-    }
-    async write(directory, catalog) {
-        const temporary = join(directory, `${randomUUID()}.tmp`);
-        const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
-        try {
-            await handle.writeFile(JSON.stringify(catalog));
-            await handle.sync();
-            await handle.close();
-            await rename(temporary, join(directory, 'catalog.json'));
-        }
-        finally {
-            await handle.close();
-            await unlink(temporary).catch(error => { if (error.code !== 'ENOENT')
-                throw error; });
-        }
-    }
-    async discover(root, source = { kind: 'discovered' }, sourcePaths = []) {
-        const key = `${this.stateDir}\0${this.workspaceId}`;
-        const previous = serial.get(key) ?? Promise.resolve();
-        const task = previous.catch(() => undefined).then(() => this.scan(root, source, sourcePaths));
-        serial.set(key, task);
-        try {
-            return await task;
-        }
-        finally {
-            if (serial.get(key) === task)
-                serial.delete(key);
-        }
-    }
-    async list() {
-        const catalog = await this.read(await this.directory());
-        return workspaceArtifactListSchema.parse({ artifacts: outputArtifacts(catalog.artifacts), scannedAt: catalog.scannedAt });
-    }
-    async scan(root, source, sourcePaths) {
-        const directory = await this.directory();
-        const objects = await artifactDirectory(directory, 'objects');
-        const catalog = await this.read(directory);
-        const original = JSON.stringify(outputArtifacts(catalog.artifacts));
-        const receipts = await this.receipts(root, catalog);
-        for (const receipt of receipts) {
-            try {
-                for (const file of receipt.files) {
-                    const copied = await snapshotArtifactFile(root, `${ARTIFACT_RECEIPTS_DIRECTORY}/objects/${file.sha256}`, objects);
-                    if (copied.sha256 !== file.sha256 || copied.size !== file.size)
-                        throw new Error('artifact_receipt_digest_mismatch');
-                }
-                const primary = receipt.files.find(file => file.role === 'primary' && file.path === receipt.path);
-                if (!primary || !artifactFormat(receipt.path))
-                    continue;
-                const version = {
-                    id: `version_${receipt.id}`, createdAt: receipt.source.generatedAt ?? new Date().toISOString(),
-                    path: receipt.path, mimeType: primary.mimeType, size: primary.size, sha256: primary.sha256,
-                    files: receipt.files, source: receipt.source,
-                    ...(receipt.width ? { width: receipt.width } : {}), ...(receipt.height ? { height: receipt.height } : {}),
-                    ...(receipt.duration !== undefined ? { duration: receipt.duration } : {}),
-                };
-                this.add(catalog, version);
-                catalog.receipts.push(receipt.id);
-            }
-            catch { /* An incomplete receipt stays pending; the next scan retries its original bytes. */ }
-        }
-        const candidates = await discoverPaths(root);
-        // Models are inspected before images so their explicitly referenced textures stay under the model.
-        candidates.sort((a, b) => Number(artifactFormat(b)?.[0] === 'model') - Number(artifactFormat(a)?.[0] === 'model') || a.localeCompare(b));
-        const visible = outputArtifacts(catalog.artifacts);
-        const members = new Set(visible.flatMap(artifact => artifact.versions.flatMap(version => version.files.filter(file => file.role !== 'primary').map(file => file.path))));
-        for (const path of candidates) {
-            if (members.has(path))
-                continue;
-            try {
-                const current = visible.find(artifact => artifact.id === artifactId(this.workspaceId, path));
-                const version = current?.versions.find(entry => entry.id === current.currentVersionId);
-                const knownWrite = sourcePaths.includes(path) && Boolean(source.operationId) && version?.source.operationId !== source.operationId;
-                const observation = catalog.observations[path];
-                if (!knownWrite && version && observation?.versionId === version.id && observation.signature === await fileSignature(root, version.files.map(file => file.path)))
-                    continue;
-                const thumbnail = version?.files.find(file => file.role === 'thumbnail');
-                const thumbnailPath = thumbnail && await lstat(join(root, thumbnail.path)).then(stat => stat.isFile(), () => false) ? thumbnail.path : undefined;
-                const paths = [path, ...await artifactResources(root, path), ...(thumbnailPath ? [thumbnailPath] : [])];
-                const signature = await fileSignature(root, paths);
-                const files = await snapshotArtifactBundle(root, path, objects, thumbnailPath);
-                if (signature !== await fileSignature(root, files.map(file => file.path)))
-                    continue;
-                for (const file of files)
-                    if (file.role !== 'primary')
-                        members.add(file.path);
-                if (!knownWrite && version && artifactBundleDigest(version.files) === artifactBundleDigest(files)) {
-                    catalog.observations[path] = { signature, versionId: version.id };
-                    continue;
-                }
-                const primary = files[0];
-                const next = {
-                    id: `version_${knownWrite ? source.operationId : randomUUID()}`, createdAt: new Date().toISOString(),
-                    path, mimeType: primary.mimeType, size: primary.size, sha256: primary.sha256, files,
-                    source: sourcePaths.includes(path) ? source : { kind: 'discovered' },
-                    ...await this.dimensions(objects, primary),
-                };
-                this.add(catalog, next);
-                catalog.observations[path] = { signature, versionId: next.id };
-            }
-            catch { /* Files being written or temporarily missing are retried, never published as complete. */ }
-        }
-        catalog.artifacts = catalog.artifacts.filter(artifact => {
-            const current = artifact.versions.find(version => version.id === artifact.currentVersionId);
-            return !isWorkspaceArtifactOutputVersion(current) || current.source.kind !== 'discovered' || !members.has(current.path);
-        });
-        catalog.artifacts.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt) || a.id.localeCompare(b.id));
-        catalog.scannedAt = new Date().toISOString();
-        const list = workspaceArtifactListSchema.parse({ artifacts: outputArtifacts(catalog.artifacts), scannedAt: catalog.scannedAt });
-        await this.write(directory, catalog);
-        return { list, changed: original !== JSON.stringify(list.artifacts) };
-    }
-    add(catalog, version) {
-        const id = artifactId(this.workspaceId, version.path);
-        let artifact = catalog.artifacts.find(item => item.id === id);
-        if (!artifact) {
-            artifact = { id, kind: artifactFormat(version.path)[0], name: basename(version.path), currentVersionId: version.id, updatedAt: version.createdAt, versions: [] };
-            catalog.artifacts.push(artifact);
-        }
-        if (!artifact.versions.some(item => item.id === version.id)) {
-            // Display ordering is monotonic; the original generation time stays in source.generatedAt.
-            const latest = Math.max(0, ...artifact.versions.map(item => Date.parse(item.createdAt)));
-            version.createdAt = new Date(Math.max(Date.parse(version.createdAt), latest + 1)).toISOString();
-            artifact.versions.unshift(version);
-        }
-        artifact.currentVersionId = version.id;
-        artifact.updatedAt = version.createdAt;
-    }
-    async receipts(root, catalog) {
-        let directory;
-        try {
-            const target = join(root, ARTIFACT_RECEIPTS_DIRECTORY);
-            if (!(await lstat(target)).isDirectory())
-                return [];
-            directory = await artifactDirectory(root, ARTIFACT_RECEIPTS_DIRECTORY);
-        }
-        catch {
-            return [];
-        }
-        const seen = new Set(catalog.receipts), receipts = [];
-        for (const name of await readdir(directory)) {
-            if (!/^[a-f0-9-]{36}\.json$/.test(name) || seen.has(name.slice(0, -5)))
-                continue;
-            try {
-                const receipt = await readArtifactReceipt(join(directory, name));
-                if (receipt.workspaceId === this.workspaceId && `${receipt.id}.json` === name && isWorkspaceArtifactOutputVersion(receipt))
-                    receipts.push(receipt);
-            }
-            catch { /* Malformed output metadata is never trusted as a completed artifact. */ }
-        }
-        return receipts.sort((a, b) => (a.source.generatedAt ?? '').localeCompare(b.source.generatedAt ?? '') || a.id.localeCompare(b.id));
-    }
-    async dimensions(objects, file) {
-        if (!file.mimeType.startsWith('image/') || file.mimeType === 'image/svg+xml')
-            return {};
-        try {
-            const metadata = await sharp(join(objects, file.sha256), { limitInputPixels: 100_000_000 }).metadata();
-            return { ...(metadata.width ? { width: metadata.width } : {}), ...(metadata.height ? { height: metadata.height } : {}) };
-        }
-        catch {
-            return {};
-        }
-    }
-    async content(input) {
-        const query = workspaceArtifactContentQuerySchema.parse(input);
-        const directory = await this.directory(), catalog = await this.read(directory);
-        const artifact = catalog.artifacts.find(item => item.id === query.artifactId);
-        const version = artifact?.versions.find(item => item.id === query.versionId && isWorkspaceArtifactOutputVersion(item));
-        const file = version?.files.find(item => item.path === (query.path ?? version.path));
-        if (!file)
-            throw new Error('artifact_not_found');
-        if (query.offset > file.size)
-            throw new Error('artifact_range_invalid');
-        const handle = await open(join(directory, 'objects', file.sha256), constants.O_RDONLY | constants.O_NOFOLLOW);
-        try {
-            const stat = await handle.stat();
-            if (!stat.isFile() || stat.nlink !== 1 || stat.size !== file.size)
-                throw new Error('artifact_snapshot_invalid');
-            const bytes = Buffer.alloc(Math.min(query.length, file.size - query.offset));
-            let read = 0;
-            while (read < bytes.length) {
-                const part = await handle.read(bytes, read, bytes.length - read, query.offset + read);
-                if (!part.bytesRead)
-                    throw new Error('artifact_snapshot_invalid');
-                read += part.bytesRead;
-            }
-            return { content: bytes.toString('base64'), mimeType: file.mimeType, totalBytes: file.size, offset: query.offset, sha256: file.sha256 };
-        }
-        finally {
-            await handle.close();
-        }
-    }
-}
-async function fileSignature(root, paths) {
-    const records = [];
-    for (const path of [...new Set(paths)].sort()) {
-        const stat = await lstat(await artifactPath(root, path));
-        if (!stat.isFile() || stat.nlink !== 1)
-            throw new Error('artifact_file_unavailable');
-        records.push([path, stat.dev, stat.ino, stat.size, stat.mtimeMs, stat.ctimeMs]);
-    }
-    return JSON.stringify(records);
-}
-async function discoverPaths(root, directory = WORKSPACE_ARTIFACT_OUTPUT_DIRECTORY, result = []) {
-    if (directory !== WORKSPACE_ARTIFACT_OUTPUT_DIRECTORY && !isWorkspaceArtifactOutputPath(directory))
-        throw new Error('invalid_artifact_path');
-    let target;
-    try {
-        target = await artifactPath(root, directory);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return result;
-        throw error;
-    }
-    if (!(await lstat(target)).isDirectory())
-        throw new Error('invalid_artifact_directory');
-    for (const entry of await readdir(target, { withFileTypes: true })) {
-        if (entry.name.startsWith('.') || entry.isSymbolicLink())
-            continue;
-        const path = `${directory}/${entry.name}`;
-        if (entry.isDirectory()) {
-            await discoverPaths(root, path, result);
-        }
-        else if (entry.isFile() && artifactFormat(path))
-            result.push(path);
-    }
-    return result;
-}