@playcraft/cli 0.1.53-beta → 0.1.54

package/dist/workspace-runtime/workspaces/asset-publication-access.js

@@ -1,25 +0,0 @@
-import { constants } from 'node:fs';
-import { lstat, open } from 'node:fs/promises';
-async function shareWithWorkspaceGroup(root, handle, directory) {
-    const workspace = await lstat(root), target = await handle.stat();
-    if (!workspace.isDirectory() || workspace.isSymbolicLink()
-        || (directory ? !target.isDirectory() : !target.isFile() || target.nlink !== 1))
-        throw new Error('invalid_workspace_asset');
-    if (target.gid !== workspace.gid)
-        await handle.chown(target.uid, workspace.gid);
-    // Match directory-access.ts: the development group can read and edit public project files.
-    // Private transfers, chunks, transaction records and backups never use these helpers.
-    await handle.chmod(directory ? 0o2770 : 0o660);
-}
-export async function shareWorkspaceAssetFile(root, handle) {
-    await shareWithWorkspaceGroup(root, handle, false);
-}
-export async function shareWorkspaceAssetDirectory(root, path) {
-    const handle = await open(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
-    try {
-        await shareWithWorkspaceGroup(root, handle, true);
-    }
-    finally {
-        await handle.close();
-    }
-}

package/dist/workspace-runtime/workspaces/asset-transfer-dependencies.js

@@ -1,81 +0,0 @@
-import { constants } from 'node:fs';
-import { open } from 'node:fs/promises';
-import { extname, join, posix } from 'node:path';
-import { AssetTransferError, safeAssetTransferDirectory } from './asset-transfer-storage.js';
-const METADATA_MAX_BYTES = 8 * 1024 * 1024;
-/** Parse only bounded model metadata; all external dependencies must be explicit package members. */
-export async function validateAssetTransferDependencies(transfer) {
-    const paths = new Set(transfer.record.manifest.files.map(file => file.path));
-    for (const [index, file] of transfer.record.manifest.files.entries()) {
-        const extension = extname(file.path).toLowerCase();
-        if (extension !== '.gltf' && extension !== '.glb')
-            continue;
-        await safeAssetTransferDirectory(transfer.directory, 'incoming');
-        const handle = await open(join(transfer.directory, 'incoming', String(index)), constants.O_RDONLY | constants.O_NOFOLLOW);
-        try {
-            let start = 0, size = file.size;
-            if (extension === '.glb') {
-                const header = Buffer.alloc(20);
-                const read = await handle.read(header, 0, header.length, 0);
-                if (read.bytesRead !== 20 || header.readUInt32LE(0) !== 0x46546c67 || header.readUInt32LE(4) !== 2
-                    || header.readUInt32LE(8) !== file.size || header.readUInt32LE(16) !== 0x4e4f534a)
-                    throw new AssetTransferError('asset_transfer_invalid_model');
-                size = header.readUInt32LE(12);
-                start = 20;
-            }
-            if (size > METADATA_MAX_BYTES)
-                throw new AssetTransferError('asset_transfer_metadata_too_large', 413);
-            if (size < 2 || size + start > file.size)
-                throw new AssetTransferError('asset_transfer_invalid_model');
-            const bytes = Buffer.alloc(size);
-            let offset = 0;
-            while (offset < size) {
-                const read = await handle.read(bytes, offset, size - offset, start + offset);
-                if (!read.bytesRead)
-                    throw new AssetTransferError('asset_transfer_invalid_model');
-                offset += read.bytesRead;
-            }
-            let body;
-            try {
-                body = JSON.parse(bytes.toString('utf8'));
-            }
-            catch {
-                throw new AssetTransferError('asset_transfer_invalid_model');
-            }
-            if (!body || typeof body !== 'object' || Array.isArray(body)
-                || !Array.isArray(body.buffers ?? []) || !Array.isArray(body.images ?? []))
-                throw new AssetTransferError('asset_transfer_invalid_model');
-            for (const resource of [...(body.buffers ?? []), ...(body.images ?? [])]) {
-                if (!resource || typeof resource !== 'object' || Array.isArray(resource))
-                    throw new AssetTransferError('asset_transfer_invalid_model');
-                if (resource.uri === undefined)
-                    continue;
-                if (typeof resource.uri !== 'string')
-                    throw new AssetTransferError('asset_transfer_invalid_model');
-                const target = assetTransferDependencyPath(file, resource.uri);
-                if (target && !paths.has(target))
-                    throw new AssetTransferError('asset_transfer_missing_dependency');
-            }
-        }
-        finally {
-            await handle.close();
-        }
-    }
-}
-function assetTransferDependencyPath(file, uri) {
-    if (/^data:/i.test(uri))
-        return undefined;
-    let decoded;
-    try {
-        decoded = decodeURIComponent(uri);
-    }
-    catch {
-        throw new AssetTransferError('asset_transfer_invalid_dependency');
-    }
-    if (!decoded || /^[a-z][a-z\d+.-]*:/i.test(decoded) || /^[\/\\]/.test(decoded) || /[\\:\x00-\x1f\x7f?#]/.test(decoded))
-        throw new AssetTransferError('asset_transfer_invalid_dependency');
-    const target = posix.normalize(posix.join(posix.dirname(file.path), decoded));
-    if (target === '..' || target.startsWith('../'))
-        throw new AssetTransferError('asset_transfer_invalid_dependency');
-    return target;
-}

package/dist/workspace-runtime/workspaces/asset-transfer-publish.js

@@ -1,438 +0,0 @@
-import { createHash } from 'node:crypto';
-import { constants } from 'node:fs';
-import { link, lstat, mkdir, open, readdir, realpath, rename, rm, rmdir, unlink } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { ASSET_TRANSFER_CHUNK_BYTES, assetBundleSavePayloadSchema, assetBundleReceiptSchema, isAssetBundleReceiptForManifest, } from '@playcraft/common/cloud-workspace/runtime';
-import { AssetTransferError, assetTransferMissing, hashAssetTransferFile, safeAssetTransferDirectory, saveAssetTransfer, syncAssetTransferDirectory, withAssetTransfer, } from './asset-transfer-storage.js';
-import { validateAssetTransferDependencies } from './asset-transfer-dependencies.js';
-import { shareWorkspaceAssetDirectory, shareWorkspaceAssetFile } from './asset-publication-access.js';
-const same = (left, right) => left.dev === right.dev && left.ino === right.ino
-    && left.size === right.size && left.contentHash === right.contentHash;
-async function targetFile(transfer, path) {
-    try {
-        await safeAssetTransferDirectory(transfer.root, dirname(path) === '.' ? '' : dirname(path));
-        return await hashAssetTransferFile(join(transfer.root, path));
-    }
-    catch (error) {
-        if (assetTransferMissing(error))
-            return undefined;
-        throw error;
-    }
-}
-async function privateFile(transfer, directory, index) {
-    try {
-        await safeAssetTransferDirectory(transfer.directory, directory);
-        return await hashAssetTransferFile(join(transfer.directory, directory, String(index)), undefined, true);
-    }
-    catch (error) {
-        if (assetTransferMissing(error))
-            return undefined;
-        throw error;
-    }
-}
-async function assertSource(transfer, file) {
-    if (file.source && (await targetFile(transfer, file.source.path))?.contentHash !== file.source.contentHash)
-        throw new AssetTransferError('source_content_conflict');
-}
-async function assemble(transfer) {
-    await safeAssetTransferDirectory(transfer.directory, 'chunks', true);
-    await safeAssetTransferDirectory(transfer.directory, 'incoming', true);
-    const staged = [];
-    for (const [index, file] of transfer.record.manifest.files.entries()) {
-        const destination = join(transfer.directory, 'incoming', String(index));
-        const output = await open(destination, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
-        const hash = createHash('sha256');
-        try {
-            for (const [chunkIndex, expected] of file.chunkHashes.entries()) {
-                let input;
-                try {
-                    input = await open(join(transfer.directory, 'chunks', `${index}-${chunkIndex}`), constants.O_RDONLY | constants.O_NOFOLLOW);
-                }
-                catch (error) {
-                    if (assetTransferMissing(error))
-                        throw new AssetTransferError('asset_transfer_incomplete');
-                    throw error;
-                }
-                try {
-                    const stat = await input.stat();
-                    const size = Math.min(ASSET_TRANSFER_CHUNK_BYTES, file.size - chunkIndex * ASSET_TRANSFER_CHUNK_BYTES);
-                    if (!stat.isFile() || stat.nlink !== 1 || stat.size !== size)
-                        throw new AssetTransferError('asset_transfer_chunk_mismatch');
-                    const bytes = await input.readFile();
-                    if (bytes.length !== size || createHash('sha256').update(bytes).digest('hex') !== expected)
-                        throw new AssetTransferError('asset_transfer_chunk_mismatch');
-                    hash.update(bytes);
-                    await output.writeFile(bytes);
-                }
-                finally {
-                    await input.close();
-                }
-            }
-            await shareWorkspaceAssetFile(transfer.root, output);
-            await output.sync();
-        }
-        finally {
-            await output.close();
-        }
-        const contentHash = hash.digest('hex');
-        if (file.contentHash && file.contentHash !== contentHash)
-            throw new AssetTransferError('asset_transfer_content_mismatch');
-        const sampled = await hashAssetTransferFile(destination);
-        if (sampled.size !== file.size || sampled.contentHash !== contentHash)
-            throw new AssetTransferError('asset_transfer_content_mismatch');
-        staged.push(sampled);
-    }
-    return staged;
-}
-function validatePublication(transfer) {
-    const publication = transfer.record.publication;
-    if (!publication || publication.manifestHash !== transfer.record.manifestHash
-        || typeof publication.operationId !== 'string' || !publication.operationId || publication.operationId.length > 128
-        || !Array.isArray(publication.files) || publication.files.length !== transfer.record.manifest.files.length
-        || !Array.isArray(publication.directories))
-        throw new AssetTransferError('asset_transfer_recovery_required');
-    for (const file of publication.files)
-        for (const identity of [file.staged, file.previous].filter(Boolean)) {
-            if (!identity || !Number.isSafeInteger(identity.dev) || !Number.isSafeInteger(identity.ino) || !Number.isSafeInteger(identity.size)
-                || !/^[a-f0-9]{64}$/.test(identity.contentHash))
-                throw new AssetTransferError('asset_transfer_recovery_required');
-        }
-    for (const directory of publication.directories) {
-        if (typeof directory.path !== 'string' || !Number.isSafeInteger(directory.dev) || !Number.isSafeInteger(directory.ino)
-            || ![...transfer.record.manifest.files.map(file => file.path), ...(transfer.record.manifest.directories ?? [])]
-                .some(path => path === directory.path || path.startsWith(directory.path + '/')))
-            throw new AssetTransferError('asset_transfer_recovery_required');
-    }
-    if (publication.markers?.some(marker => !Number.isSafeInteger(marker.dev) || !Number.isSafeInteger(marker.ino)
-        || !transfer.record.manifest.directories?.includes(marker.path)))
-        throw new AssetTransferError('asset_transfer_recovery_required');
-    return publication;
-}
-async function createDirectories(transfer, path) {
-    const publication = validatePublication(transfer);
-    let directory = '';
-    for (const part of path.split('/').filter(Boolean)) {
-        directory = [directory, part].filter(Boolean).join('/');
-        try {
-            await safeAssetTransferDirectory(transfer.root, directory);
-        }
-        catch (error) {
-            if (!assetTransferMissing(error))
-                throw error;
-            await safeAssetTransferDirectory(transfer.root, dirname(directory) === '.' ? '' : dirname(directory));
-            await mkdir(join(transfer.root, directory), { mode: 0o700 });
-            await shareWorkspaceAssetDirectory(transfer.root, join(transfer.root, directory));
-            const stat = await lstat(await safeAssetTransferDirectory(transfer.root, directory));
-            publication.directories.push({ path: directory, dev: stat.dev, ino: stat.ino });
-            await saveAssetTransfer(transfer);
-        }
-    }
-}
-async function cleanPublicationFiles(transfer, completed = false) {
-    for (const name of completed ? ['chunks', 'incoming', 'previous'] : ['incoming', 'previous']) {
-        try {
-            await safeAssetTransferDirectory(transfer.directory, name);
-            await rm(join(transfer.directory, name), { recursive: true });
-        }
-        catch (error) {
-            if (!assetTransferMissing(error))
-                throw error;
-        }
-    }
-}
-async function ensureDirectoryMarkers(transfer) {
-    const publication = validatePublication(transfer);
-    for (const path of transfer.record.manifest.directories ?? []) {
-        const parent = await safeAssetTransferDirectory(transfer.root, path);
-        const marker = join(parent, '.gitkeep');
-        try {
-            const handle = await open(marker, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
-            try {
-                await shareWorkspaceAssetFile(transfer.root, handle);
-                await handle.sync();
-                const stat = await handle.stat();
-                (publication.markers ??= []).push({ path, dev: stat.dev, ino: stat.ino });
-                await saveAssetTransfer(transfer);
-            }
-            finally {
-                await handle.close();
-            }
-            await syncAssetTransferDirectory(parent);
-        }
-        catch (error) {
-            if (error.code !== 'EEXIST')
-                throw error;
-            const stat = await lstat(marker);
-            if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1)
-                throw new AssetTransferError('content_conflict');
-        }
-    }
-}
-async function assertCompletedTargets(transfer) {
-    if (!isAssetBundleReceiptForManifest(transfer.record.manifest, transfer.record.manifestHash, transfer.record.receipt))
-        throw new AssetTransferError('asset_transfer_content_mismatch');
-    for (const [index, file] of transfer.record.manifest.files.entries()) {
-        await safeAssetTransferDirectory(transfer.root, dirname(file.path) === '.' ? '' : dirname(file.path));
-        const current = await hashAssetTransferFile(join(transfer.root, file.path), undefined, false, file.chunkHashes);
-        const saved = transfer.record.receipt.files[index];
-        if (saved.path !== file.path || current.size !== file.size || current.contentHash !== saved.contentHash)
-            throw new AssetTransferError('asset_transfer_content_mismatch');
-    }
-    for (const directory of transfer.record.manifest.directories ?? [])
-        await safeAssetTransferDirectory(transfer.root, directory);
-}
-async function finishPublication(transfer) {
-    const publication = validatePublication(transfer);
-    const files = [];
-    for (const [index, file] of transfer.record.manifest.files.entries()) {
-        await safeAssetTransferDirectory(transfer.root, dirname(file.path) === '.' ? '' : dirname(file.path));
-        const current = await hashAssetTransferFile(join(transfer.root, file.path), undefined, false, file.chunkHashes);
-        if (!current || !same(current, publication.files[index].staged))
-            throw new AssetTransferError('content_conflict');
-        files.push({ path: file.path, size: current.size, contentHash: current.contentHash });
-    }
-    await ensureDirectoryMarkers(transfer);
-    const receipt = assetBundleReceiptSchema.parse({ transferId: transfer.record.manifest.transferId,
-        manifestHash: transfer.record.manifestHash, files,
-        ...(transfer.record.manifest.directories ? { directories: transfer.record.manifest.directories } : {}) });
-    if (!isAssetBundleReceiptForManifest(transfer.record.manifest, transfer.record.manifestHash, receipt))
-        throw new AssetTransferError('asset_transfer_content_mismatch');
-    transfer.record.status = 'completed';
-    transfer.record.receipt = receipt;
-    await saveAssetTransfer(transfer);
-    await cleanPublicationFiles(transfer, true).catch(() => undefined);
-    return receipt;
-}
-/** Complete only this journal's exclusive link/unlink pairs left behind by a crash. */
-async function normalizePublicationAliases(transfer) {
-    const publication = validatePublication(transfer);
-    for (const [index, file] of transfer.record.manifest.files.entries()) {
-        const parent = dirname(file.path) === '.' ? '' : dirname(file.path);
-        try {
-            await safeAssetTransferDirectory(transfer.root, parent);
-        }
-        catch (error) {
-            if (assetTransferMissing(error))
-                continue;
-            throw error;
-        }
-        const target = join(transfer.root, file.path);
-        const targetStat = await lstat(target).catch(error => { if (assetTransferMissing(error))
-            return undefined; throw error; });
-        if (!targetStat || targetStat.nlink === 1)
-            continue;
-        if (!targetStat.isFile() || targetStat.isSymbolicLink() || targetStat.nlink !== 2)
-            throw new AssetTransferError('asset_transfer_recovery_required');
-        let normalized = false;
-        for (const [directory, expected] of [['incoming', publication.files[index].staged], ['previous', publication.files[index].previous]]) {
-            if (!expected || targetStat.dev !== expected.dev || targetStat.ino !== expected.ino)
-                continue;
-            try {
-                await safeAssetTransferDirectory(transfer.directory, directory);
-            }
-            catch (error) {
-                if (assetTransferMissing(error))
-                    continue;
-                throw error;
-            }
-            const alias = join(transfer.directory, directory, String(index));
-            const aliasStat = await lstat(alias).catch(error => { if (assetTransferMissing(error))
-                return undefined; throw error; });
-            if (!aliasStat || !aliasStat.isFile() || aliasStat.isSymbolicLink() || aliasStat.nlink !== 2
-                || aliasStat.dev !== expected.dev || aliasStat.ino !== expected.ino)
-                continue;
-            const observed = await hashAssetTransferFile(target, undefined, true);
-            if (!same(observed, expected))
-                throw new AssetTransferError('asset_transfer_recovery_required');
-            // Recheck both names immediately before unlinking the known private alias.
-            const [current, privateAlias] = await Promise.all([lstat(target), lstat(alias)]);
-            if (current.dev !== expected.dev || current.ino !== expected.ino || current.nlink !== 2
-                || privateAlias.dev !== expected.dev || privateAlias.ino !== expected.ino || privateAlias.nlink !== 2)
-                throw new AssetTransferError('asset_transfer_recovery_required');
-            await unlink(alias);
-            await syncAssetTransferDirectory(join(transfer.directory, directory));
-            normalized = true;
-            break;
-        }
-        if (!normalized)
-            throw new AssetTransferError('asset_transfer_recovery_required');
-    }
-}
-/** Roll back only files still owned by this publication; preserve concurrent external edits and backups. */
-async function rollbackPublication(transfer) {
-    await normalizePublicationAliases(transfer);
-    const publication = validatePublication(transfer);
-    let conflict = false;
-    for (let index = publication.files.length - 1; index >= 0; index--) {
-        const file = transfer.record.manifest.files[index], expected = publication.files[index];
-        try {
-            const current = await targetFile(transfer, file.path);
-            const backup = await privateFile(transfer, 'previous', index);
-            if (backup) {
-                if (!expected.previous || !same(backup, expected.previous)) {
-                    conflict = true;
-                    continue;
-                }
-                if (current) {
-                    if (!same(current, expected.staged)) {
-                        conflict = true;
-                        continue;
-                    }
-                    await unlink(join(transfer.root, file.path));
-                }
-                await safeAssetTransferDirectory(transfer.root, dirname(file.path) === '.' ? '' : dirname(file.path));
-                await link(join(transfer.directory, 'previous', String(index)), join(transfer.root, file.path));
-                await unlink(join(transfer.directory, 'previous', String(index)));
-                await syncAssetTransferDirectory(join(transfer.root, dirname(file.path)));
-            }
-            else if (current && same(current, expected.staged)) {
-                if (expected.previous) {
-                    conflict = true;
-                    continue;
-                }
-                await unlink(join(transfer.root, file.path));
-            }
-            else if (expected.previous && (!current || !same(current, expected.previous)))
-                conflict = true;
-        }
-        catch {
-            conflict = true;
-        }
-    }
-    if (conflict)
-        throw new AssetTransferError('asset_transfer_recovery_required');
-    for (const marker of publication.markers ?? []) {
-        try {
-            const parent = await safeAssetTransferDirectory(transfer.root, marker.path);
-            const path = join(parent, '.gitkeep'), stat = await lstat(path);
-            if (stat.dev === marker.dev && stat.ino === marker.ino && stat.isFile() && stat.nlink === 1 && stat.size === 0)
-                await unlink(path);
-        }
-        catch (error) {
-            if (!assetTransferMissing(error))
-                throw error;
-        }
-    }
-    for (const directory of [...publication.directories].reverse()) {
-        try {
-            const target = await safeAssetTransferDirectory(transfer.root, directory.path);
-            const stat = await lstat(target);
-            if (stat.dev === directory.dev && stat.ino === directory.ino)
-                await rmdir(target);
-        }
-        catch (error) {
-            if (!assetTransferMissing(error) && !['ENOTEMPTY', 'EEXIST'].includes(String(error.code)))
-                throw error;
-        }
-    }
-    transfer.record.status = 'uploading';
-    delete transfer.record.publication;
-    delete transfer.record.receipt;
-    await saveAssetTransfer(transfer);
-    await cleanPublicationFiles(transfer);
-}
-export async function recoverAssetTransfer(transfer) {
-    if (transfer.record.status === 'completed') {
-        await assertCompletedTargets(transfer);
-        await cleanPublicationFiles(transfer, true);
-        return;
-    }
-    if (transfer.record.status !== 'publishing')
-        return;
-    await normalizePublicationAliases(transfer);
-    try {
-        await finishPublication(transfer);
-    }
-    catch {
-        await rollbackPublication(transfer);
-    }
-}
-export async function publishAssetTransfer(root, scope, input, options) {
-    const payload = assetBundleSavePayloadSchema.parse(input);
-    return withAssetTransfer(root, scope, payload.transferId, async (transfer) => {
-        if (transfer.record.manifestHash !== payload.manifestHash)
-            throw new AssetTransferError('asset_transfer_manifest_conflict');
-        options.onManifest?.(transfer.record.manifest);
-        await recoverAssetTransfer(transfer);
-        if (transfer.record.status === 'completed')
-            return transfer.record.receipt;
-        await options.assertCurrent?.();
-        await cleanPublicationFiles(transfer);
-        let staged;
-        try {
-            staged = await assemble(transfer);
-            await validateAssetTransferDependencies(transfer);
-        }
-        catch (error) {
-            await cleanPublicationFiles(transfer);
-            throw error;
-        }
-        const previous = [];
-        for (const file of transfer.record.manifest.files) {
-            const observed = await targetFile(transfer, file.path);
-            if ((observed?.contentHash ?? null) !== file.expectedContentHash)
-                throw new AssetTransferError('content_conflict');
-            await assertSource(transfer, file);
-            await options.assertRevision?.(file, observed);
-            previous.push(observed);
-        }
-        transfer.record.status = 'publishing';
-        transfer.record.publication = { operationId: options.operationId, manifestHash: payload.manifestHash,
-            files: staged.map((identity, index) => ({ staged: identity, ...(previous[index] ? { previous: previous[index] } : {}) })), directories: [] };
-        await saveAssetTransfer(transfer);
-        try {
-            await safeAssetTransferDirectory(transfer.directory, 'previous', true);
-            for (const directory of transfer.record.manifest.directories ?? [])
-                await createDirectories(transfer, directory);
-            for (const [index, file] of transfer.record.manifest.files.entries()) {
-                await options.assertCurrent?.();
-                await createDirectories(transfer, dirname(file.path) === '.' ? '' : dirname(file.path));
-                const current = await targetFile(transfer, file.path);
-                if (previous[index] ? !current || !same(current, previous[index]) : current)
-                    throw new AssetTransferError('content_conflict');
-                await assertSource(transfer, file);
-                if (current) {
-                    await rename(join(transfer.root, file.path), join(transfer.directory, 'previous', String(index)));
-                    const backup = await privateFile(transfer, 'previous', index);
-                    if (!backup || !same(backup, current))
-                        throw new AssetTransferError('content_conflict');
-                    await syncAssetTransferDirectory(join(transfer.directory, 'previous'));
-                }
-                await safeAssetTransferDirectory(transfer.root, dirname(file.path) === '.' ? '' : dirname(file.path));
-                // Creating the destination with link refuses a concurrently-created file instead of overwriting it.
-                await link(join(transfer.directory, 'incoming', String(index)), join(transfer.root, file.path));
-                await unlink(join(transfer.directory, 'incoming', String(index)));
-                await syncAssetTransferDirectory(join(transfer.root, dirname(file.path)));
-                await options.onPublishedFile?.(index);
-            }
-            await options.assertCurrent?.();
-            return await finishPublication(transfer);
-        }
-        catch (error) {
-            await rollbackPublication(transfer);
-            throw error;
-        }
-    });
-}
-export async function recoverAssetTransfers(root, scope) {
-    const recovered = [];
-    let directory;
-    try {
-        directory = await safeAssetTransferDirectory(await realpath(root), '.playcraft-temp/asset-transfers');
-    }
-    catch (error) {
-        if (assetTransferMissing(error))
-            return recovered;
-        throw error;
-    }
-    for (const item of await readdir(directory, { withFileTypes: true })) {
-        if (!item.isDirectory() || !/^[a-f0-9-]{36}$/i.test(item.name))
-            continue;
-        await withAssetTransfer(root, scope, item.name, async (transfer) => {
-            await recoverAssetTransfer(transfer);
-            if (transfer.record.status === 'completed' && transfer.record.publication?.operationId)
-                recovered.push({ operationId: transfer.record.publication.operationId, receipt: transfer.record.receipt, manifest: transfer.record.manifest });
-        }).catch(() => undefined);
-    }
-    return recovered;
-}