@playcraft/cli 0.1.54 → 0.1.56-beta

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

@@ -0,0 +1,112 @@
+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 { shareWorkspaceAssetDirectory } from './asset-publication-access.js';
+import { excludeFromGit } from './dependencies.js';
+export const ARTIFACT_RECEIPTS_DIRECTORY = '.playcraft/artifact-receipts';
+export const artifactReceiptSchema = workspaceArtifactReceiptSchema;
+export 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;
+    }
+}
+/**
+ * The receipt tree is written by the development identity and read by the controller. A directory
+ * the other identity created cannot be re-shaped here; its owner repairs it on the next write and
+ * readers keep working from whatever already carries the shared bits.
+ */
+async function shareArtifactDirectory(root, directory) {
+    try {
+        await shareWorkspaceAssetDirectory(root, directory);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== 'EACCES' && code !== 'EPERM')
+            throw error;
+    }
+}
+/** Preserve final outputs before another command overwrites them; intermediate project assets are not registered. */
+export async function captureGeneratedArtifact(output, tool, metadata = {}, cwd = process.cwd(), expectedDigest, origin) {
+    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`);
+    // Generations are written as the development identity while the controller scans this tree.
+    await shareArtifactDirectory(context.root, receipts);
+    await shareArtifactDirectory(context.root, objects);
+    const thumbnailPath = metadata.thumbnailPath ? relativeArtifactPath(context.root, resolve(cwd, metadata.thumbnailPath)) : undefined;
+    const files = await snapshotArtifactBundle(context.root, path, objects, thumbnailPath);
+    if (expectedDigest && files.find(file => file.role === 'primary')?.sha256 !== expectedDigest)
+        throw new Error('artifact_file_changed');
+    const receipt = artifactReceiptSchema.parse({
+        id: randomUUID(), workspaceId: context.workspaceId, path,
+        source: { kind: 'generated', tool, generatedAt: new Date().toISOString(),
+            ...(origin?.sessionId ? { sessionId: origin.sessionId } : {}), ...(origin?.operationId ? { operationId: origin.operationId } : {}) }, 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, 0o660);
+    try {
+        await handle.chmod(0o660);
+        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

@@ -0,0 +1,380 @@
+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';
+import { validateWorkspacePlayable } from '../previews/finalize.js';
+import { PREVIEW_HTML_MAX_BYTES, WORKSPACE_PLAYABLE_OUTPUT_PATH } from '@playcraft/common/cloud-workspace/runtime';
+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;
+    directoryName;
+    constructor(stateDir, workspaceId, directoryName = 'basic') {
+        this.stateDir = stateDir;
+        this.workspaceId = workspaceId;
+        this.directoryName = directoryName;
+        if (!/^(basic|remix-[a-z0-9][a-z0-9-]{3,63})$/.test(directoryName))
+            throw new Error('invalid_workspace_directory');
+    }
+    get scopeId() { return this.directoryName === 'basic' ? this.workspaceId : `${this.workspaceId}:${this.directoryName}`; }
+    async directory() {
+        await mkdir(this.stateDir, { recursive: true, mode: 0o700 });
+        return artifactDirectory(this.stateDir, `artifacts/${digest(this.scopeId)}`);
+    }
+    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 = {}, playable, ...body } = JSON.parse(await handle.readFile('utf8'));
+            if (!Array.isArray(receipts) || receipts.some(id => typeof id !== 'string'))
+                throw new Error('artifact_catalog_invalid');
+            if (playable && (!Array.isArray(playable.pending) || playable.pending.some(value => typeof value !== 'string')
+                || playable.rejectedDigest !== undefined && !/^[a-f0-9]{64}$/.test(playable.rejectedDigest)))
+                throw new Error('artifact_catalog_invalid');
+            return { ...workspaceArtifactListSchema.parse(body), receipts, observations, ...(playable ? { playable } : {}) };
+        }
+        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 = [], playable = {}) {
+        const key = `${this.stateDir}\0${this.scopeId}`;
+        const previous = serial.get(key) ?? Promise.resolve();
+        const task = previous.catch(() => undefined).then(() => this.scan(root, source, sourcePaths, playable));
+        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 rejectedPlayable(bytes) {
+        return (await this.read(await this.directory())).playable?.rejectedDigest === createHash('sha256').update(bytes).digest('hex');
+    }
+    async hasPendingPlayableExecution(executionId) {
+        return (await this.read(await this.directory())).playable?.pending.some(id => id.split('/').length > 2 && id !== executionId) ?? false;
+    }
+    async isCurrentPlayable(bytes) {
+        const catalog = await this.read(await this.directory());
+        const artifact = catalog.artifacts.find(item => item.kind === 'playable' && item.versions.some(version => version.path === WORKSPACE_PLAYABLE_OUTPUT_PATH));
+        return artifact?.versions.find(item => item.id === artifact.currentVersionId)?.sha256 === createHash('sha256').update(bytes).digest('hex');
+    }
+    async scan(root, source, sourcePaths, playable) {
+        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 gate = catalog.playable ??= { pending: [] };
+        if (playable.mode === 'skip' || playable.mode === 'failure')
+            gate.initialized = true;
+        if (playable.executionId) {
+            gate.pending = gate.pending.filter(id => id !== playable.executionId && (playable.mode === 'hold' || !id.startsWith(`${playable.executionId}/`)));
+            if (playable.mode === 'hold')
+                gate.pending.push(playable.executionId);
+        }
+        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 } : {}),
+                };
+                const kind = await this.versionKind(objects, version);
+                await this.add(catalog, version, kind, objects);
+                if (kind === 'playable') {
+                    gate.rejectedDigest = undefined;
+                    gate.initialized = true;
+                }
+                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;
+            if (path === WORKSPACE_PLAYABLE_OUTPUT_PATH && ['hold', 'skip'].includes(playable.mode ?? ''))
+                continue;
+            if (path === WORKSPACE_PLAYABLE_OUTPUT_PATH && gate.initialized && !['success', 'failure'].includes(playable.mode ?? ''))
+                continue;
+            try {
+                const current = visible.find(artifact => artifact.id === artifactId(this.scopeId, 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 && (path !== WORKSPACE_PLAYABLE_OUTPUT_PATH || current?.kind === 'playable')
+                    && 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 && (path !== WORKSPACE_PLAYABLE_OUTPUT_PATH || current?.kind === 'playable')
+                    && artifactBundleDigest(version.files) === artifactBundleDigest(files)) {
+                    catalog.observations[path] = { signature, versionId: version.id };
+                    continue;
+                }
+                const primary = files[0];
+                if (path === WORKSPACE_PLAYABLE_OUTPUT_PATH) {
+                    if (playable.mode === 'failure') {
+                        gate.rejectedDigest = primary.sha256;
+                        gate.initialized = true;
+                        continue;
+                    }
+                    if (playable.mode === 'success'
+                        ? gate.pending.some(id => id.split('/').length > 2)
+                        : gate.pending.length > 0)
+                        continue;
+                    if (gate.rejectedDigest === primary.sha256 && !playable.force)
+                        continue;
+                }
+                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),
+                };
+                const kind = await this.versionKind(objects, next);
+                await this.add(catalog, next, kind, objects);
+                if (kind === 'playable') {
+                    gate.rejectedDigest = undefined;
+                    gate.initialized = true;
+                }
+                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) };
+    }
+    async versionKind(objects, version) {
+        if (version.path !== WORKSPACE_PLAYABLE_OUTPUT_PATH)
+            return artifactFormat(version.path)[0];
+        if (version.files.length !== 1)
+            throw new Error('preview_not_single_file');
+        const primary = version.files[0];
+        const file = await open(join(objects, primary.sha256), constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            const stat = await file.stat();
+            if (!stat.isFile() || stat.nlink !== 1 || stat.size > PREVIEW_HTML_MAX_BYTES)
+                throw new Error('preview_not_single_file');
+            const bytes = await file.readFile();
+            if (bytes.length !== primary.size || createHash('sha256').update(bytes).digest('hex') !== primary.sha256)
+                throw new Error('artifact_snapshot_invalid');
+            validateWorkspacePlayable(bytes);
+        }
+        finally {
+            await file.close();
+        }
+        return 'playable';
+    }
+    async add(catalog, version, kind, objects) {
+        const id = artifactId(this.scopeId, version.path);
+        let artifact = catalog.artifacts.find(item => item.id === id);
+        if (!artifact) {
+            artifact = { id, kind, name: basename(version.path), currentVersionId: version.id, updatedAt: version.createdAt, versions: [] };
+            catalog.artifacts.push(artifact);
+        }
+        if (kind === 'playable' && artifact.kind !== 'playable') {
+            const valid = await Promise.all(artifact.versions.map(async (item) => {
+                try {
+                    return await this.versionKind(objects, item) === 'playable' ? item : undefined;
+                }
+                catch {
+                    return undefined;
+                }
+            }));
+            artifact.versions = valid.filter((item) => Boolean(item));
+        }
+        artifact.kind = kind;
+        if (this.directoryName !== 'basic')
+            version.directoryName = this.directoryName;
+        const current = artifact.versions.find(item => item.id === artifact.currentVersionId);
+        if (kind === 'playable' && current && artifactBundleDigest(current.files) === artifactBundleDigest(version.files))
+            return;
+        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 = [];
+        // A receipt tree the current identity cannot read is skipped rather than failing the scan.
+        const names = await readdir(directory).catch(() => []);
+        for (const name of names) {
+            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;
+}