@playcraft/cli 0.1.53-beta → 0.1.54

package/dist/workspace-runtime/workspaces/directory-revisions.js

@@ -1,56 +0,0 @@
-import { createHash } from 'node:crypto';
-import { lstat } from 'node:fs/promises';
-import { join } from 'node:path';
-import { isMutableWorkspaceDirectoryPath } from '@playcraft/common/cloud-workspace/runtime';
-import { listWorkspaceFiles } from './files.js';
-/** Reuse the listing's streamed hashes; only directory and preservation-marker metadata is sampled again. */
-export async function observeWorkspaceDirectories(root, journal, scope, listed) {
-    const previous = journal.fileRevisions(scope);
-    const result = listed ?? await listWorkspaceFiles(root, previous);
-    const directoryRevisions = {};
-    const fingerprints = new Map();
-    for (const path of result.directories ?? []) {
-        if (!isMutableWorkspaceDirectoryPath(path)
-            || result.unreadablePaths?.some(item => item === path || item.startsWith(`${path}/`)))
-            continue;
-        const stat = await lstat(join(root, ...path.split('/')));
-        if (!stat.isDirectory() || stat.isSymbolicLink())
-            continue;
-        const marker = await lstat(join(root, ...path.split('/'), '.gitkeep')).catch(error => {
-            if (error.code !== 'ENOENT')
-                throw error;
-            return undefined;
-        });
-        fingerprints.set(path, JSON.stringify([path, stat.dev, stat.ino, stat.mtimeMs, stat.ctimeMs,
-            marker && [marker.dev, marker.ino, marker.size, marker.mtimeMs, marker.ctimeMs]]));
-    }
-    for (const [path] of fingerprints) {
-        const hash = createHash('sha256').update('directory\0');
-        for (const [child, metadata] of fingerprints)
-            if (child === path || child.startsWith(`${path}/`))
-                hash.update(metadata);
-        for (const file of result.files)
-            if (file.path.startsWith(`${path}/`))
-                hash.update(JSON.stringify([file.path, file.contentHash, file.size]));
-        const contentHash = hash.digest('hex');
-        const old = previous[path];
-        const revision = old ? old.revision + Number(old.contentHash !== contentHash) : 0;
-        if (!old || old.contentHash !== contentHash)
-            await journal.putFileRevision(path, { revision, contentHash }, scope);
-        directoryRevisions[path] = revision;
-    }
-    for (const file of result.files) {
-        const old = previous[file.path];
-        const revision = old ? old.revision + Number(old.contentHash !== file.contentHash) : 0;
-        if (!old || old.contentHash !== file.contentHash)
-            await journal.putFileRevision(file.path, { revision, contentHash: file.contentHash }, scope);
-        file.revision = revision;
-    }
-    // Retain tombstones so recreating the same path cannot satisfy an old revision.
-    const present = new Set([...result.files.map(file => file.path), ...(result.directories ?? [])]);
-    for (const [path, old] of Object.entries(previous)) {
-        if (old.contentHash && !present.has(path) && !result.unreadablePaths?.some(item => path === item || path.startsWith(`${item}/`)))
-            await journal.putFileRevision(path, { revision: old.revision + 1, contentHash: '' }, scope);
-    }
-    return { ...result, directoryRevisions };
-}

package/dist/workspace-runtime/workspaces/directory-stats.js

@@ -1,49 +0,0 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { workspaceRoot, WorkspaceContextError } from './registry.js';
-const execute = promisify(execFile);
-/** Measures registered checkouts only when requested; journal activity never scans private neighboring workspaces. */
-export async function readWorkspaceDirectoryStats(state, workspaceId) {
-    const binding = state.journal.getWorkspace(workspaceId);
-    if (!binding)
-        throw new WorkspaceContextError('workspace_not_registered');
-    const names = [...new Set(['basic', ...(binding.directories ?? []).map(directory => directory.directoryName)])];
-    const operations = state.journal.listOperations().map(item => item.operation).filter(operation => operation.workspaceId === workspaceId);
-    const events = state.journal.listEvents().flatMap(event => {
-        const payload = event.payload && typeof event.payload === 'object' ? event.payload : {};
-        const session = typeof payload.sessionId === 'string' ? state.journal.getSession(payload.sessionId) : undefined;
-        if ((payload.workspaceId ?? session?.workspaceId) !== workspaceId)
-            return [];
-        return [{ directoryName: String(payload.directoryName ?? session?.directoryName ?? 'basic'), occurredAt: event.occurredAt }];
-    });
-    const latest = (dates) => {
-        const timestamps = dates.map(value => Date.parse(value)).filter(Number.isFinite);
-        return timestamps.length ? new Date(Math.max(...timestamps)).toISOString() : null;
-    };
-    const directories = [];
-    for (const directoryName of names) {
-        const lastUsedAt = latest([...operations.filter(operation => (operation.directoryName ?? 'basic') === directoryName).map(operation => operation.updatedAt),
-            ...events.filter(event => event.directoryName === directoryName).map(event => event.occurredAt)]);
-        if (binding.directories?.some(directory => directory.directoryName === directoryName && directory.status === 'reclaimed')) {
-            directories.push({ directoryName, sizeBytes: 0, lastUsedAt, status: 'reclaimed' });
-            continue;
-        }
-        let root;
-        try {
-            root = await workspaceRoot(state, workspaceId, directoryName);
-        }
-        catch (error) {
-            if (!(error instanceof WorkspaceContextError) || error.message !== 'workspace_not_prepared')
-                throw error;
-            directories.push({ directoryName, sizeBytes: 0, lastUsedAt, status: 'missing' });
-            continue;
-        }
-        const output = await execute('du', ['-sk', root], { timeout: 30_000, maxBuffer: 4096 });
-        const blocks = Number(output.stdout.trim().split(/\s+/)[0]);
-        if (!Number.isSafeInteger(blocks) || blocks < 0 || !Number.isSafeInteger(blocks * 1024))
-            throw new Error('workspace_directory_stats_invalid');
-        directories.push({ directoryName, sizeBytes: blocks * 1024, lastUsedAt, status: 'present' });
-    }
-    return { workspaceId, sizeBytes: directories.reduce((sum, directory) => sum + directory.sizeBytes, 0),
-        lastUsedAt: latest([...operations.map(operation => operation.updatedAt), ...events.map(event => event.occurredAt)]), directories };
-}

package/dist/workspace-runtime/workspaces/disk-snapshot.js

@@ -1,31 +0,0 @@
-import { createHash } from 'node:crypto';
-import { constants } from 'node:fs';
-import { open } from 'node:fs/promises';
-import { ASSET_TRANSFER_FILE_MAX_BYTES } from '@playcraft/common/cloud-workspace/runtime';
-export async function sampleDiskFile(path) {
-    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        const before = await handle.stat();
-        if (!before.isFile() || before.size > ASSET_TRANSFER_FILE_MAX_BYTES)
-            throw new Error('snapshot_body_missing');
-        const digest = createHash('sha256');
-        const chunk = Buffer.allocUnsafe(64 * 1024);
-        let position = 0;
-        for (;;) {
-            const { bytesRead } = await handle.read(chunk, 0, chunk.length, position);
-            if (!bytesRead)
-                break;
-            digest.update(chunk.subarray(0, bytesRead));
-            position += bytesRead;
-            if (position > ASSET_TRANSFER_FILE_MAX_BYTES)
-                throw new Error('snapshot_body_missing');
-        }
-        const after = await handle.stat();
-        if (before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs || position !== before.size)
-            throw new Error('snapshot_body_missing');
-        return { hash: digest.digest('hex'), size: position, mode: before.mode & 0o777, modifiedAt: before.mtime.toISOString() };
-    }
-    finally {
-        await handle.close();
-    }
-}

package/dist/workspace-runtime/workspaces/empty-template.js

@@ -1,42 +0,0 @@
-import { cp, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { resolveCliPackageRoot } from '../../scaffold/compose.js';
-import { importBuiltinProjectSkills } from '../../project-skills/builtin-import.js';
-import { createHash } from 'node:crypto';
-import { canonicalProjectSkillsJson } from '@playcraft/common/project-skills';
-import { syncLocalProjectSkills } from '../../project-skills/local-store.js';
-import { selectOptionalPlatformSkills } from './optional-platform-skills.js';
-export const EMPTY_WORKSPACE_REPOSITORY_SKILLS = [
-    'playcraft-skill-recommender',
-    'playcraft-image-generation',
-    'playcraft-audio-generation',
-    'playcraft-image-processing',
-    'playcraft-build-optimizer',
-];
-export const EMPTY_WORKSPACE_PLATFORM_SKILLS = ['playcraft-video-understanding', 'playcraft-replica-validation'];
-export const EMPTY_WORKSPACE_DEFAULT_SKILLS = [...EMPTY_WORKSPACE_REPOSITORY_SKILLS, ...EMPTY_WORKSPACE_PLATFORM_SKILLS];
-/** Only called in a new, unpublished staging directory; existing workspaces are never scaffolded. */
-export async function scaffoldEmptyWorkspace(root, skillCache, access) {
-    const selected = await selectOptionalPlatformSkills([...EMPTY_WORKSPACE_PLATFORM_SKILLS], access);
-    const cliRoot = resolveCliPackageRoot();
-    const template = join(cliRoot, 'project-templates', 'empty');
-    for (const [source, target] of [
-        ['gitignore', '.gitignore'],
-        ['AGENTS.md', 'AGENTS.md'],
-    ]) {
-        await cp(join(template, source), join(root, target), { force: false, errorOnExist: true });
-    }
-    const skills = join(root, '.agents', 'skills');
-    await mkdir(skills, { recursive: true });
-    for (const name of EMPTY_WORKSPACE_REPOSITORY_SKILLS) {
-        await cp(join(cliRoot, 'project-template', '.claude', 'skills', name), join(skills, name), {
-            recursive: true,
-            force: false,
-            errorOnExist: true,
-        });
-    }
-    const snapshot = await syncLocalProjectSkills(root, skillCache);
-    if (selected)
-        await importBuiltinProjectSkills(root, { names: [...EMPTY_WORKSPACE_PLATFORM_SKILLS], expectedDeclarationHash: snapshot.lock.declarationHash,
-            expectedLockHash: createHash('sha256').update(canonicalProjectSkillsJson(snapshot.lock)).digest('hex') }, skillCache, access, selected, true);
-}

package/dist/workspace-runtime/workspaces/file-content.js

@@ -1,48 +0,0 @@
-import { constants } from 'node:fs';
-import { lstat, open } from 'node:fs/promises';
-import { basename, extname } from 'node:path';
-import { workspaceRelativePathSchema } from '@playcraft/common/cloud-workspace/runtime';
-import { artifactMime, artifactPath } from './artifact-files.js';
-import { serveOpenedWorkspaceContent } from './binary-content.js';
-import { InvalidWorkspacePathError, resolveWorkspaceFile } from './files.js';
-const additionalMediaTypes = {
-    '.aac': 'audio/aac', '.opus': 'audio/ogg', '.oga': 'audio/ogg', '.aif': 'audio/aiff', '.aiff': 'audio/aiff',
-    '.bmp': 'image/bmp', '.ico': 'image/vnd.microsoft.icon', '.heic': 'image/heic', '.heif': 'image/heif',
-    '.tif': 'image/tiff', '.tiff': 'image/tiff',
-};
-export async function serveWorkspaceFileContent(root, path, request, response) {
-    let handle;
-    let size;
-    try {
-        if (!workspaceRelativePathSchema.safeParse(path).success)
-            throw new InvalidWorkspacePathError(path);
-        // Check every component before resolving, so missing files cannot create parent directories.
-        await artifactPath(root, path);
-        const target = await resolveWorkspaceFile(root, path);
-        handle = await open(target, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
-        const stat = await handle.stat();
-        if (!stat.isFile() || stat.nlink !== 1)
-            throw new Error('file_not_found');
-        // Bind the open handle to the authorized file even if a parent changed during open.
-        const verified = await artifactPath(root, path);
-        const current = await lstat(verified);
-        if (!current.isFile() || current.nlink !== 1 || current.dev !== stat.dev || current.ino !== stat.ino)
-            throw new InvalidWorkspacePathError(path);
-        size = stat.size;
-    }
-    catch (error) {
-        await handle?.close();
-        const code = error?.code;
-        const invalid = error instanceof InvalidWorkspacePathError || (error instanceof Error && error.message === 'invalid_artifact_path');
-        const denied = code === 'EACCES' || code === 'EPERM';
-        response.writeHead(invalid ? 400 : denied ? 403 : 404, { 'content-type': 'application/json', 'cache-control': 'no-store' });
-        response.end(JSON.stringify({ error: invalid ? 'invalid_workspace_path' : denied ? 'workspace_permission_denied' : 'file_not_found' }));
-        return;
-    }
-    await serveOpenedWorkspaceContent({
-        handle,
-        name: basename(path),
-        mimeType: additionalMediaTypes[extname(path).toLowerCase()] ?? artifactMime(path),
-        size,
-    }, request, response);
-}

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

@@ -1,116 +0,0 @@
-import { createHash } from 'node:crypto';
-import { lstat, opendir, realpath } from 'node:fs/promises';
-import { join, relative, sep } from 'node:path';
-import { workspaceFileSearchQuerySchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
-const SKIP_DIRECTORIES = new Set(['.git', 'node_modules', '.playcraft', '.next', 'dist', 'build', 'coverage', '.turbo']);
-const SCAN_PAGE_ENTRIES = 1000;
-export class InvalidWorkspaceSearchError extends Error {
-    code;
-    constructor(code = 'invalid_workspace_search') {
-        super(code);
-        this.code = code;
-        this.name = 'InvalidWorkspaceSearchError';
-    }
-}
-/** Enumerates names only. The cursor is scoped to the resolved checkout and query, never to a caller supplied path. */
-export async function searchWorkspaceFiles(root, query, options = {}) {
-    const parsed = workspaceFileSearchQuerySchema.safeParse(query);
-    if (!parsed.success)
-        throw new InvalidWorkspaceSearchError();
-    options.signal?.throwIfAborted();
-    const rootReal = await realpath(root);
-    const needle = parsed.data.query.toLocaleLowerCase();
-    const scope = createHash('sha256').update(rootReal).update('\0').update(needle).digest('hex');
-    const start = decodeCursor(parsed.data.cursor, scope);
-    const files = [];
-    let offset = 0;
-    for await (const path of walk(rootReal, rootReal, options.signal)) {
-        options.signal?.throwIfAborted();
-        offset += 1;
-        if (offset <= start)
-            continue;
-        if (path && path.toLocaleLowerCase().includes(needle)) {
-            const target = join(rootReal, ...path.split('/'));
-            const info = await lstat(target).catch(ignoreUnavailable);
-            const targetReal = info?.isFile() && !info.isSymbolicLink() ? await realpath(target).catch(ignoreUnavailable) : undefined;
-            if (targetReal && inside(rootReal, targetReal))
-                files.push({ path });
-        }
-        if (files.length >= parsed.data.limit || offset - start >= SCAN_PAGE_ENTRIES) {
-            return { files, truncated: true, nextCursor: encodeCursor(scope, offset) };
-        }
-    }
-    return { files, truncated: false };
-}
-async function* walk(root, current, signal) {
-    signal?.throwIfAborted();
-    const currentInfo = await lstat(current).catch(ignoreUnavailable);
-    if (!currentInfo?.isDirectory() || currentInfo.isSymbolicLink())
-        return;
-    const resolved = await realpath(current).catch(ignoreUnavailable);
-    if (!resolved || !inside(root, resolved))
-        return;
-    const directory = await opendir(resolved).catch(ignoreUnavailable);
-    if (!directory)
-        return;
-    // Recheck after opening: a concurrently replaced directory must not reveal another checkout's paths.
-    const openedPath = await realpath(current).catch(ignoreUnavailable);
-    if (openedPath !== resolved || !inside(root, openedPath)) {
-        await directory.close();
-        return;
-    }
-    for await (const entry of directory) {
-        signal?.throwIfAborted();
-        if (['.git', 'node_modules', '.playcraft'].includes(entry.name)) {
-            yield undefined;
-            continue;
-        }
-        const child = join(resolved, entry.name);
-        const path = relative(root, child).split(sep).join('/');
-        if (!workspaceRelativePathSchema.safeParse(path).success) {
-            yield undefined;
-            continue;
-        }
-        if (entry.isDirectory()) {
-            yield undefined;
-            if (!SKIP_DIRECTORIES.has(entry.name))
-                yield* walk(root, child, signal);
-            continue;
-        }
-        if (!entry.isFile()) {
-            yield undefined;
-            continue;
-        }
-        yield path;
-    }
-}
-function inside(root, path) {
-    const value = relative(root, path);
-    return value === '' || (value !== '..' && !value.startsWith(`..${sep}`) && !value.startsWith(sep));
-}
-function ignoreUnavailable(error) {
-    if (['ENOENT', 'ENOTDIR', 'EACCES'].includes(error.code ?? ''))
-        return undefined;
-    throw error;
-}
-function encodeCursor(scope, offset) {
-    return Buffer.from(JSON.stringify({ v: 1, scope, offset })).toString('base64url');
-}
-function decodeCursor(cursor, scope) {
-    if (!cursor)
-        return 0;
-    try {
-        if (!/^[A-Za-z0-9_-]+$/.test(cursor))
-            throw new Error();
-        const value = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
-        if (typeof value !== 'object' || value === null)
-            throw new Error();
-        const { v, scope: suppliedScope, offset } = value;
-        if (v !== 1 || suppliedScope !== scope || typeof offset !== 'number' || !Number.isSafeInteger(offset) || offset < 0)
-            throw new Error();
-        return offset;
-    }
-    catch {
-        throw new InvalidWorkspaceSearchError('invalid_workspace_search_cursor');
-    }
-}

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

@@ -1,150 +0,0 @@
-import { lstat, mkdir, readdir, readFile, realpath, writeFile } from 'node:fs/promises';
-import { createHash } from 'node:crypto';
-import { dirname, join, relative, resolve, sep } from 'node:path';
-import { hashWorkspaceFileContent, workspaceFileContentSchema, workspaceFileListSchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
-import { sampleDiskFile } from './disk-snapshot.js';
-const SKIP_DIRECTORY_NAMES = new Set(['.git', 'node_modules', '.playcraft-temp']);
-const LARGE_FILE_STREAM_THRESHOLD = 8 * 1024 * 1024;
-export class InvalidWorkspacePathError extends Error {
-    code = 'invalid_workspace_path';
-    constructor(path) {
-        super(path);
-        this.name = 'InvalidWorkspacePathError';
-    }
-}
-export async function ensureWorkspaceRoot(root) {
-    await mkdir(root, { recursive: true, mode: 0o700 });
-    return realpath(root);
-}
-export async function resolveWorkspaceFile(root, relativePath) {
-    const parsed = workspaceRelativePathSchema.safeParse(relativePath);
-    if (!parsed.success)
-        throw new InvalidWorkspacePathError(relativePath);
-    const rootReal = await ensureWorkspaceRoot(root);
-    const target = resolve(rootReal, ...parsed.data.split('/'));
-    assertInsideRoot(rootReal, target);
-    try {
-        const existing = await realpath(target);
-        assertInsideRoot(rootReal, existing);
-        return existing;
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT')
-            throw error;
-        await assertParentInsideRoot(rootReal, dirname(target));
-        return target;
-    }
-}
-export async function writeWorkspaceFile(root, relativePath, content) {
-    const target = await resolveWorkspaceFile(root, relativePath);
-    await mkdir(dirname(target), { recursive: true, mode: 0o700 });
-    const bytes = Buffer.from(content, 'utf8');
-    await writeFile(target, bytes, { mode: 0o600 });
-    return { path: relativePath, contentHash: hashWorkspaceFileContent(content), size: bytes.byteLength };
-}
-export async function readWorkspaceFile(root, relativePath, revisions) {
-    const target = await resolveWorkspaceFile(root, relativePath);
-    const content = await readFile(target, 'utf8');
-    const contentHash = hashWorkspaceFileContent(content);
-    return workspaceFileContentSchema.parse({
-        path: relativePath,
-        revision: revisions[relativePath]?.revision ?? 0,
-        contentHash,
-        content,
-    });
-}
-export async function listWorkspaceFiles(root, revisions) {
-    const rootReal = await ensureWorkspaceRoot(root);
-    const files = [];
-    const directories = new Set();
-    const unreadablePaths = new Set();
-    for (const relativePath of await walkWorkspaceFiles(rootReal, rootReal, unreadablePaths, directories)) {
-        const target = join(rootReal, ...relativePath.split('/'));
-        try {
-            const stat = await lstat(target);
-            if (stat.size > LARGE_FILE_STREAM_THRESHOLD) {
-                const sampled = await sampleDiskFile(target);
-                files.push({ path: relativePath, revision: revisions[relativePath]?.revision ?? 0, contentHash: sampled.hash, size: sampled.size, modifiedAt: sampled.modifiedAt });
-                continue;
-            }
-            const content = await readFile(target);
-            const after = await lstat(target);
-            if (stat.ino !== after.ino || stat.size !== after.size || stat.mtimeMs !== after.mtimeMs || stat.ctimeMs !== after.ctimeMs || content.length !== after.size) {
-                const sampled = await sampleDiskFile(target);
-                files.push({ path: relativePath, revision: revisions[relativePath]?.revision ?? 0, contentHash: sampled.hash, size: sampled.size, modifiedAt: sampled.modifiedAt });
-                continue;
-            }
-            files.push({
-                path: relativePath,
-                revision: revisions[relativePath]?.revision ?? 0,
-                contentHash: createHash('sha256').update(content).digest('hex'),
-                size: content.byteLength,
-                modifiedAt: after.mtime.toISOString(),
-            });
-        }
-        catch (error) {
-            if (!isPermissionDenied(error))
-                throw error;
-            unreadablePaths.add(relativePath);
-        }
-    }
-    files.sort((left, right) => left.path.localeCompare(right.path));
-    return workspaceFileListSchema.parse({ files, directories: [...directories].sort(), ...(unreadablePaths.size ? { unreadablePaths: [...unreadablePaths].sort() } : {}) });
-}
-async function walkWorkspaceFiles(rootReal, current, unreadablePaths, directories) {
-    const entries = await readdir(current, { withFileTypes: true });
-    const paths = [];
-    for (const entry of entries) {
-        const child = join(current, entry.name);
-        try {
-            if (entry.isDirectory()) {
-                if (SKIP_DIRECTORY_NAMES.has(entry.name) || entry.name === '.' || entry.name === '..')
-                    continue;
-                const childReal = await realpath(child);
-                assertInsideRoot(rootReal, childReal);
-                const children = await walkWorkspaceFiles(rootReal, childReal, unreadablePaths, directories);
-                directories.add(toPosixRelative(rootReal, childReal));
-                paths.push(...children);
-                continue;
-            }
-            if (!entry.isFile() || entry.name === '.gitkeep')
-                continue;
-            const childReal = await realpath(child);
-            assertInsideRoot(rootReal, childReal);
-            paths.push(toPosixRelative(rootReal, childReal));
-        }
-        catch (error) {
-            if (!isPermissionDenied(error))
-                throw error;
-            unreadablePaths.add(toPosixRelative(rootReal, child));
-        }
-    }
-    return paths;
-}
-function isPermissionDenied(error) {
-    return ['EACCES', 'EPERM'].includes(String(error?.code));
-}
-async function assertParentInsideRoot(rootReal, parent) {
-    if (parent === rootReal)
-        return;
-    try {
-        const parentReal = await realpath(parent);
-        assertInsideRoot(rootReal, parentReal);
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT')
-            throw error;
-        await mkdir(parent, { recursive: true, mode: 0o700 });
-        const parentReal = await realpath(parent);
-        assertInsideRoot(rootReal, parentReal);
-    }
-}
-function assertInsideRoot(rootReal, target) {
-    const rel = relative(rootReal, target);
-    if (rel === '' || rel.startsWith(`..${sep}`) || rel === '..' || rel.startsWith('..')) {
-        throw new InvalidWorkspacePathError(target);
-    }
-}
-function toPosixRelative(rootReal, target) {
-    return relative(rootReal, target).split(sep).join('/');
-}