fundus 0.0.4 → 0.2.0

package/dist/server/raw-reconciliation.js

@@ -0,0 +1,338 @@
+import { createHash } from 'node:crypto';
+import { constants } from 'node:fs';
+import { lstat, open, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { compareCodeUnits, folderPathError, isFundusTransactionName, portableRawPathKey, rawFilePathError } from '../core/index.js';
+function objectIdentity(value) {
+    return `${value.dev}:${value.ino}:${value.mode}`;
+}
+function fileIdentity(value) {
+    return `${objectIdentity(value)}:${value.size}:${value.mtimeNs}:${value.ctimeNs}`;
+}
+function pathMatchesHandle(pathStat, handleStat) {
+    return pathStat.isFile() && objectIdentity(pathStat) === objectIdentity(handleStat);
+}
+/** Hash one regular file without following its final path component. */
+export async function stableRawFileHash(path) {
+    let lastProblem;
+    for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+            const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+            try {
+                const before = await handle.stat({ bigint: true });
+                const pathBefore = await lstat(path, { bigint: true });
+                if (!before.isFile() || !pathMatchesHandle(pathBefore, before)) {
+                    throw new Error('path is not the opened regular file');
+                }
+                const hash = createHash('sha256');
+                for await (const chunk of handle.createReadStream({ autoClose: false }))
+                    hash.update(chunk);
+                const after = await handle.stat({ bigint: true });
+                const pathAfter = await lstat(path, { bigint: true });
+                if (fileIdentity(before) === fileIdentity(after) && pathMatchesHandle(pathAfter, after)) {
+                    return hash.digest('hex');
+                }
+                lastProblem = new Error('changed while it was being hashed');
+            }
+            finally {
+                await handle.close().catch(() => { });
+            }
+        }
+        catch (cause) {
+            lastProblem = cause;
+        }
+    }
+    throw lastProblem instanceof Error ? lastProblem : new Error(String(lastProblem));
+}
+export async function verifyStableRawFile(path, expectedHash) {
+    const actualHash = await stableRawFileHash(path);
+    if (actualHash !== expectedHash) {
+        throw new Error(`Raw source changed (expected ${expectedHash}, found ${actualHash}).`);
+    }
+}
+/** Enumerate without following symlinks and retain structural scan completeness. */
+export async function scanRawDirectory(rawDir, includeFile = () => true) {
+    const files = [];
+    const blockers = [];
+    const diagnostics = [];
+    const occupiedPaths = new Set();
+    const entryKinds = new Map();
+    const ignoredRegularPaths = [];
+    let complete = true;
+    function markIncomplete(path, reason) {
+        complete = false;
+        diagnostics.push({ path, reason });
+    }
+    async function visit(folder) {
+        const absolutePath = join(rawDir, folder);
+        let before;
+        try {
+            before = await lstat(absolutePath, { bigint: true });
+        }
+        catch (cause) {
+            markIncomplete(folder, `${folder === '' ? 'Raw directory' : `Directory "${folder}"`} cannot be read: ${cause instanceof Error ? cause.message : String(cause)}`);
+            return;
+        }
+        if (!before.isDirectory() || before.isSymbolicLink()) {
+            markIncomplete(folder, `${folder === '' ? 'Raw directory' : `Directory "${folder}"`} is not a regular directory.`);
+            return;
+        }
+        let entries;
+        try {
+            entries = await readdir(absolutePath, { withFileTypes: true });
+        }
+        catch (cause) {
+            markIncomplete(folder, `${folder === '' ? 'Raw directory' : `Directory "${folder}"`} cannot be traversed: ${cause instanceof Error ? cause.message : String(cause)}`);
+            return;
+        }
+        for (const entry of entries.sort((a, b) => compareCodeUnits(a.name, b.name))) {
+            const path = folder === '' ? entry.name : `${folder}/${entry.name}`;
+            if (entry.name === '.gitkeep' || isFundusTransactionName(entry.name))
+                continue;
+            if (entry.isDirectory()) {
+                occupiedPaths.add(path);
+                entryKinds.set(path, 'directory');
+                const problem = folderPathError(path);
+                if (problem)
+                    blockers.push({ path, reason: problem });
+                else
+                    await visit(path);
+                continue;
+            }
+            if (entry.isFile()) {
+                // Unsupported regular files do not exist from Fundus's perspective.
+                if (!includeFile(path)) {
+                    ignoredRegularPaths.push(path);
+                    continue;
+                }
+                occupiedPaths.add(path);
+                entryKinds.set(path, 'file');
+                const problem = rawFilePathError(path);
+                if (problem) {
+                    blockers.push({ path, reason: problem });
+                    continue;
+                }
+                try {
+                    files.push({ path, hash: await stableRawFileHash(join(rawDir, path)) });
+                }
+                catch (cause) {
+                    blockers.push({
+                        path,
+                        reason: `Could not obtain a stable file hash: ${cause instanceof Error ? cause.message : String(cause)}`
+                    });
+                }
+                continue;
+            }
+            const kind = entry.isSymbolicLink() ? 'symlink' : 'special';
+            occupiedPaths.add(path);
+            entryKinds.set(path, kind);
+            blockers.push({ path, reason: 'Symlinks and special files are not supported.' });
+        }
+        try {
+            const after = await lstat(absolutePath, { bigint: true });
+            if (!after.isDirectory() || objectIdentity(before) !== objectIdentity(after)) {
+                markIncomplete(folder, `${folder === '' ? 'Raw directory' : `Directory "${folder}"`} changed during traversal.`);
+            }
+        }
+        catch (cause) {
+            markIncomplete(folder, `${folder === '' ? 'Raw directory' : `Directory "${folder}"`} changed during traversal: ${cause instanceof Error ? cause.message : String(cause)}`);
+        }
+    }
+    await visit('');
+    const collisions = new Map();
+    for (const path of [...occupiedPaths].sort(compareCodeUnits)) {
+        const key = portableRawPathKey(path);
+        const previous = collisions.get(key);
+        if (previous !== undefined && previous !== path) {
+            const reason = `Raw paths "${previous}" and "${path}" collide portably.`;
+            blockers.push({ path: previous, reason });
+            blockers.push({ path, reason });
+        }
+        else
+            collisions.set(key, path);
+    }
+    const blockersByPath = new Map();
+    for (const blocker of blockers) {
+        if (!blockersByPath.has(blocker.path))
+            blockersByPath.set(blocker.path, blocker);
+    }
+    const sortedBlockers = [...blockersByPath.values()].sort((a, b) => compareCodeUnits(a.path, b.path));
+    const blocked = new Set(sortedBlockers.map((entry) => entry.path));
+    return {
+        complete,
+        diagnostics: diagnostics.sort((a, b) => compareCodeUnits(a.path, b.path)),
+        files: files
+            .filter((entry) => !blocked.has(entry.path))
+            .sort((a, b) => compareCodeUnits(a.path, b.path)),
+        blockers: sortedBlockers,
+        occupiedPaths,
+        entryKinds,
+        ignoredRegularPaths: ignoredRegularPaths.sort(compareCodeUnits)
+    };
+}
+/** Pure deterministic matching: exact path first, then only 1:1 hash groups. */
+export function classifyRawFiles(library, scan) {
+    const filesByPath = new Map(scan.files.map((file) => [file.path, file]));
+    const remainingFiles = new Map(filesByPath);
+    const remainingRecords = new Map();
+    const unchangedAssetIds = [];
+    const edited = [];
+    const blockers = [...scan.blockers];
+    const excludedPrefixes = [];
+    for (const assetId of Object.keys(library.assets).sort(compareCodeUnits)) {
+        const record = library.assets[assetId];
+        const kind = scan.entryKinds.get(record.raw);
+        if (kind !== undefined && kind !== 'file') {
+            const existing = blockers.find((blocker) => blocker.path === record.raw);
+            if (existing)
+                existing.assetId = assetId;
+            else {
+                blockers.push({
+                    assetId,
+                    path: record.raw,
+                    reason: `Managed raw path is occupied by a ${kind}.`
+                });
+            }
+            excludedPrefixes.push(record.raw);
+            continue;
+        }
+        const exact = filesByPath.get(record.raw);
+        if (exact) {
+            remainingFiles.delete(record.raw);
+            if (exact.hash === record.rawHash)
+                unchangedAssetIds.push(assetId);
+            else
+                edited.push({ assetId, ...exact });
+        }
+        else if (scan.complete &&
+            !scan.occupiedPaths.has(record.raw) &&
+            !scan.blockers.some((blocker) => record.raw === blocker.path || record.raw.startsWith(`${blocker.path}/`))) {
+            remainingRecords.set(assetId, { path: record.raw, hash: record.rawHash });
+        }
+    }
+    for (const path of remainingFiles.keys()) {
+        if (excludedPrefixes.some((prefix) => path.startsWith(`${prefix}/`)))
+            remainingFiles.delete(path);
+    }
+    const recordsByHash = new Map();
+    for (const [assetId, record] of remainingRecords) {
+        recordsByHash.set(record.hash, [...(recordsByHash.get(record.hash) ?? []), assetId]);
+    }
+    const filesByHash = new Map();
+    for (const file of remainingFiles.values()) {
+        filesByHash.set(file.hash, [...(filesByHash.get(file.hash) ?? []), file]);
+    }
+    const moves = [];
+    if (scan.complete) {
+        for (const [hash, assetIds] of recordsByHash) {
+            const candidates = filesByHash.get(hash) ?? [];
+            if (assetIds.length !== 1 || candidates.length !== 1)
+                continue;
+            const assetId = assetIds[0];
+            const file = candidates[0];
+            moves.push({ assetId, from: remainingRecords.get(assetId)?.path ?? '', ...file });
+            remainingRecords.delete(assetId);
+            remainingFiles.delete(file.path);
+        }
+    }
+    const blockerKeys = new Set();
+    const uniqueBlockers = blockers.filter((blocker) => {
+        const key = `${blocker.assetId ?? ''}|${blocker.path}`;
+        if (blockerKeys.has(key))
+            return false;
+        blockerKeys.add(key);
+        return true;
+    });
+    return {
+        complete: scan.complete,
+        diagnostics: scan.diagnostics,
+        unchangedAssetIds,
+        edited: edited.sort((a, b) => compareCodeUnits(a.path, b.path)),
+        moves: scan.complete ? moves.sort((a, b) => compareCodeUnits(a.path, b.path)) : [],
+        deletions: scan.complete
+            ? [...remainingRecords].map(([assetId, record]) => ({ assetId, path: record.path }))
+            : [],
+        unmanaged: [...remainingFiles.values()].sort((a, b) => compareCodeUnits(a.path, b.path)),
+        blockers: uniqueBlockers.sort((a, b) => compareCodeUnits(a.path, b.path))
+    };
+}
+export async function classifyRawDirectory(rawDir, library, includeExternalFile = () => true) {
+    const managedPaths = new Set(Object.values(library.assets).map((record) => record.raw));
+    const scan = await scanRawDirectory(rawDir, (path) => managedPaths.has(path) || includeExternalFile(path));
+    const classification = classifyRawFiles(library, scan);
+    if (!classification.complete || classification.deletions.length === 0)
+        return classification;
+    const ignoredByHash = new Map();
+    for (const path of scan.ignoredRegularPaths) {
+        try {
+            const hash = await stableRawFileHash(join(rawDir, path));
+            ignoredByHash.set(hash, [...(ignoredByHash.get(hash) ?? []), path]);
+        }
+        catch (cause) {
+            return {
+                ...classification,
+                complete: false,
+                diagnostics: [
+                    ...classification.diagnostics,
+                    {
+                        path,
+                        reason: `Could not safely check ignored raw file "${path}" while managed files were missing: ${cause instanceof Error ? cause.message : String(cause)}`
+                    }
+                ].sort((a, b) => compareCodeUnits(a.path, b.path)),
+                moves: [],
+                deletions: []
+            };
+        }
+    }
+    const missingByHash = new Map();
+    for (const deletion of classification.deletions) {
+        const hash = library.assets[deletion.assetId].rawHash;
+        missingByHash.set(hash, [...(missingByHash.get(hash) ?? []), deletion]);
+    }
+    const supportedByHash = new Map();
+    for (const file of classification.unmanaged) {
+        supportedByHash.set(file.hash, [...(supportedByHash.get(file.hash) ?? []), file.path]);
+    }
+    const protectedAssetIds = new Set();
+    const unsupportedBlockers = [];
+    const ambiguityDiagnostics = [];
+    for (const [hash, ignoredPaths] of ignoredByHash) {
+        const missing = missingByHash.get(hash) ?? [];
+        if (missing.length === 0)
+            continue;
+        const candidatePaths = [...(supportedByHash.get(hash) ?? []), ...ignoredPaths].sort(compareCodeUnits);
+        const sortedMissing = [...missing].sort((a, b) => compareCodeUnits(a.assetId, b.assetId));
+        if (sortedMissing.length === 1 && ignoredPaths.length === 1 && candidatePaths.length === 1) {
+            const [{ assetId, path: oldPath }] = sortedMissing;
+            const [destination] = ignoredPaths;
+            protectedAssetIds.add(assetId);
+            unsupportedBlockers.push({
+                assetId,
+                path: destination,
+                reason: `Asset "${assetId}" was moved from "${oldPath}" to unsupported path "${destination}". ` +
+                    'Rename it externally to a supported extension.'
+            });
+            continue;
+        }
+        ambiguityDiagnostics.push({
+            path: candidatePaths[0] ?? '',
+            reason: `Ignored raw files ambiguously match missing assets [${sortedMissing.map((entry) => entry.assetId).join(', ')}] ` +
+                `and candidate paths [${candidatePaths.join(', ')}]. Restore or reduce the external files until the match is unique.`
+        });
+    }
+    if (ambiguityDiagnostics.length > 0) {
+        return {
+            ...classification,
+            complete: false,
+            diagnostics: [...classification.diagnostics, ...ambiguityDiagnostics].sort((a, b) => compareCodeUnits(`${a.path}|${a.reason}`, `${b.path}|${b.reason}`)),
+            moves: [],
+            deletions: [],
+            blockers: [...classification.blockers, ...unsupportedBlockers].sort((a, b) => compareCodeUnits(a.path, b.path))
+        };
+    }
+    return {
+        ...classification,
+        deletions: classification.deletions.filter((deletion) => !protectedAssetIds.has(deletion.assetId)),
+        blockers: [...classification.blockers, ...unsupportedBlockers].sort((a, b) => compareCodeUnits(a.path, b.path))
+    };
+}

package/dist/server/raw-safety.d.ts

@@ -0,0 +1,10 @@
+import type { Library, ValidationIssueDto } from '../core/index.js';
+import type { RawClassification } from './raw-reconciliation.js';
+export type RawSafetyIssueKind = 'incomplete' | 'blocker' | 'missing' | 'edited' | 'type-incompatible' | 'volatile';
+export interface RawSafetyIssue extends ValidationIssueDto {
+    kind: RawSafetyIssueKind;
+    path: string;
+}
+export declare function rawSafetyIssueKey(issue: RawSafetyIssue): string;
+/** Managed-source safety gate shared by editor operations and `fundus build`. */
+export declare function rawSafetyIssues(library: Library, classification: RawClassification, compatibleTypes: (path: string) => string[]): RawSafetyIssue[];

package/dist/server/raw-safety.js

@@ -0,0 +1,73 @@
+export function rawSafetyIssueKey(issue) {
+    return `${issue.kind}|${issue.assetId ?? ''}|${issue.path}`;
+}
+/** Managed-source safety gate shared by editor operations and `fundus build`. */
+export function rawSafetyIssues(library, classification, compatibleTypes) {
+    const issues = [];
+    if (!classification.complete) {
+        for (const diagnostic of classification.diagnostics) {
+            issues.push({
+                kind: 'incomplete',
+                path: diagnostic.path,
+                message: diagnostic.reason
+            });
+        }
+    }
+    for (const blocker of classification.blockers) {
+        const affected = blocker.assetId
+            ? [blocker.assetId]
+            : Object.entries(library.assets)
+                .filter(([, record]) => record.raw === blocker.path || record.raw.startsWith(`${blocker.path}/`))
+                .map(([assetId]) => assetId);
+        for (const assetId of affected) {
+            issues.push({
+                kind: 'blocker',
+                path: blocker.path,
+                assetId,
+                message: `Raw source "${blocker.path}" is unsafe: ${blocker.reason}`
+            });
+        }
+    }
+    for (const missing of classification.deletions) {
+        issues.push({
+            kind: 'missing',
+            path: missing.path,
+            assetId: missing.assetId,
+            message: `Raw file "${missing.path}" is missing from the raw directory.`
+        });
+    }
+    for (const move of classification.moves) {
+        issues.push({
+            kind: 'missing',
+            path: move.from,
+            assetId: move.assetId,
+            message: `Raw file "${move.from}" is missing from the raw directory.`
+        });
+    }
+    for (const edited of classification.edited) {
+        issues.push({
+            kind: 'edited',
+            path: edited.path,
+            assetId: edited.assetId,
+            message: `Raw file "${edited.path}" changed outside Fundus.`
+        });
+    }
+    for (const [assetId, record] of Object.entries(library.assets)) {
+        if (!compatibleTypes(record.raw).includes(record.type)) {
+            issues.push({
+                kind: 'type-incompatible',
+                path: record.raw,
+                assetId,
+                message: `Raw file "${record.raw}" is not compatible with its current ${record.type} type.`
+            });
+        }
+    }
+    const seen = new Set();
+    return issues.filter((issue) => {
+        const key = rawSafetyIssueKey(issue);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}

package/dist/server/start.d.ts

@@ -3,11 +3,13 @@ interface StartBannerOptions {
     port: number;
     projectRoot: string;
     color?: boolean;
+    terminalWidth?: number;
 }
 export interface RunStartOptions {
     openBrowser?: boolean;
+    port?: number;
 }
 /** Format the human startup summary without pulling a terminal UI dependency into the CLI. */
-export declare function formatStartBanner({ port, projectRoot, color }: StartBannerOptions): string;
-export declare function runStart(projectRoot: string, { openBrowser }?: RunStartOptions): Promise<void>;
+export declare function formatStartBanner({ port, projectRoot, color, terminalWidth }: StartBannerOptions): string;
+export declare function runStart(projectRoot: string, { openBrowser, port }?: RunStartOptions): Promise<void>;
 export {};

package/dist/server/start.js

@@ -8,32 +8,64 @@ export const DEFAULT_PORT = 7583;
 function ansi(code, value, enabled) {
     return enabled ? `\u001b[${code}m${value}\u001b[0m` : value;
 }
+function truncateEnd(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    if (maxLength <= 1)
+        return '…'.slice(0, maxLength);
+    return `${value.slice(0, maxLength - 1)}…`;
+}
+function truncateMiddle(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    if (maxLength <= 1)
+        return '…'.slice(0, maxLength);
+    const remainingLength = maxLength - 1;
+    const startLength = Math.floor(remainingLength / 2);
+    const endLength = remainingLength - startLength;
+    return `${value.slice(0, startLength)}…${value.slice(-endLength)}`;
+}
 /** Format the human startup summary without pulling a terminal UI dependency into the CLI. */
-export function formatStartBanner({ port, projectRoot, color = false }) {
+export function formatStartBanner({ port, projectRoot, color = false, terminalWidth }) {
     const url = `http://127.0.0.1:${port}`;
     const brand = '◆ Fundus';
-    const editor = `Editor   ${url}`;
-    const project = `Project  ${projectRoot}`;
     const ready = 'Ready · press Ctrl+C to stop';
-    const contentWidth = Math.max(42, brand.length, editor.length, project.length, ready.length);
+    const editorPrefix = 'Editor   ';
+    const projectPrefix = 'Project  ';
+    const preferredContentWidth = Math.max(42, brand.length, editorPrefix.length + url.length, projectPrefix.length + projectRoot.length, ready.length);
+    const availableContentWidth = Number.isFinite(terminalWidth) && terminalWidth !== undefined
+        ? Math.max(1, Math.floor(terminalWidth) - 4)
+        : preferredContentWidth;
+    const contentWidth = Math.min(preferredContentWidth, availableContentWidth);
+    const displayedBrand = truncateEnd(brand, contentWidth);
+    const displayedEditorPrefix = truncateEnd(editorPrefix, contentWidth);
+    const displayedUrl = truncateEnd(url, Math.max(0, contentWidth - displayedEditorPrefix.length));
+    const editor = `${displayedEditorPrefix}${displayedUrl}`;
+    const displayedProjectPrefix = truncateEnd(projectPrefix, contentWidth);
+    const displayedProjectRoot = truncateMiddle(projectRoot, Math.max(0, contentWidth - displayedProjectPrefix.length));
+    const project = `${displayedProjectPrefix}${displayedProjectRoot}`;
+    const displayedReady = truncateEnd(ready, contentWidth);
     const border = (value) => ansi('2', value, color);
+    const styledPrefix = (displayed, full, label, gap) => displayed === full ? `${ansi('2', label, color)}${gap}` : ansi('2', displayed, color);
     const row = (plain, styled = plain) => `${border('│')} ${styled}${' '.repeat(contentWidth - plain.length)} ${border('│')}`;
     const empty = row('');
     return [
         '',
         border(`╭${'─'.repeat(contentWidth + 2)}╮`),
         empty,
-        row(brand, `${ansi('38;2;24;152;243', '◆', color)} ${ansi('1', 'Fundus', color)}`),
+        row(displayedBrand, displayedBrand === brand
+            ? `${ansi('38;2;24;152;243', '◆', color)} ${ansi('1', 'Fundus', color)}`
+            : ansi('1', displayedBrand, color)),
         empty,
-        row(editor, `${ansi('2', 'Editor', color)}   ${ansi('4;36', url, color)}`),
-        row(project, `${ansi('2', 'Project', color)}  ${projectRoot}`),
+        row(editor, `${styledPrefix(displayedEditorPrefix, editorPrefix, 'Editor', '   ')}${ansi('4;36', displayedUrl, color)}`),
+        row(project, `${styledPrefix(displayedProjectPrefix, projectPrefix, 'Project', '  ')}${displayedProjectRoot}`),
         empty,
-        row(ready, ansi('32', ready, color)),
+        row(displayedReady, ansi('32', displayedReady, color)),
         empty,
         border(`╰${'─'.repeat(contentWidth + 2)}╯`)
     ].join('\n');
 }
-export async function runStart(projectRoot, { openBrowser = true } = {}) {
+export async function runStart(projectRoot, { openBrowser = true, port = DEFAULT_PORT } = {}) {
     const resolvedProjectRoot = resolve(projectRoot);
     process.env.FUNDUS_PROJECT_ROOT = resolvedProjectRoot;
     process.env.FUNDUS_BODY_SIZE_LIMIT ??= 'Infinity';
@@ -47,12 +79,12 @@ export async function runStart(projectRoot, { openBrowser = true } = {}) {
     if (typeof module.handler !== 'function') {
         throw new Error(`The packaged Fundus handler at ${fileURLToPath(handlerUrl)} is invalid.`);
     }
-    const configuredPort = Number(process.env.FUNDUS_API_PORT ?? DEFAULT_PORT);
-    const server = await startServer({ handler: module.handler, port: configuredPort });
+    const server = await startServer({ handler: module.handler, port });
     const editorUrl = `http://127.0.0.1:${server.port}`;
     console.log(formatStartBanner({
         port: server.port,
         projectRoot: resolvedProjectRoot,
+        terminalWidth: process.stdout.columns,
         color: process.stdout.isTTY === true &&
             process.env.NO_COLOR === undefined &&
             process.env.TERM !== 'dumb'

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "fundus",
-	"version": "0.0.4",
+	"version": "0.2.0",
 	"type": "module",
 	"repository": {
 		"type": "git",

package/build/client/_app/immutable/assets/0.DLhIsYA_.css

@@ -1 +0,0 @@
-:root{--panel:#2c2c2c;--panel-raised:#383838;--canvas:#1e1e1e;--border:#444;--border-soft:#383838;--text:#fff;--text-dim:#a0a0a0;--text-faint:#7a7a7a;--accent:#0d99ff;--accent-soft:#0d99ff29;--warning:#ffcd29;--warning-soft:#ffcd2924;--danger:#f24822;--ok:#14ae5c;--radius:6px;--radius-small:4px;--radius-large:8px;--font-ui:"Inter", system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;--lightningcss-light: ;--lightningcss-dark:initial;color-scheme:dark}*{box-sizing:border-box}html,body{height:100%;margin:0;padding:0}body{background:var(--canvas);color:var(--text);font-family:var(--font-ui);-webkit-font-smoothing:antialiased;font-size:12px;line-height:1.45}a{color:inherit;text-decoration:none}button,input,select{font:inherit;color:inherit}button{cursor:pointer}.control{background:var(--panel-raised);border-radius:var(--radius);border:1px solid #0000;height:28px;padding:4px 8px}.control:hover{border-color:var(--border)}.control:focus,.control:focus-visible{border-color:var(--accent);outline:none}.control.primary{background:var(--accent);color:var(--text)}.control.primary:disabled{opacity:.4;cursor:not-allowed}.control.danger{color:var(--danger)}.control.danger:hover{border-color:var(--danger)}.checkerboard{background-color:var(--canvas);background-image:linear-gradient(45deg, var(--panel) 25%, transparent 25%), linear-gradient(-45deg, var(--panel) 25%, transparent 25%), linear-gradient(45deg, transparent 75%, var(--panel) 75%), linear-gradient(-45deg, transparent 75%, var(--panel) 75%);background-position:0 0,0 8px,8px -8px,-8px 0;background-size:16px 16px}.shell.svelte-12qhfyh{flex-direction:column;height:100vh;display:flex}.topbar.svelte-12qhfyh{background:var(--panel);border-bottom:1px solid var(--border);flex:none;align-items:center;gap:24px;height:40px;padding:0 16px;display:flex}.brand.svelte-12qhfyh{align-items:center;gap:8px;font-size:12px;font-weight:600;display:inline-flex}.logo.svelte-12qhfyh{color:var(--accent)}nav.svelte-12qhfyh{gap:4px;display:flex}nav.svelte-12qhfyh a:where(.svelte-12qhfyh){border-radius:var(--radius);color:var(--text-dim);padding:4px 10px}nav.svelte-12qhfyh a:where(.svelte-12qhfyh):hover{color:var(--text)}nav.svelte-12qhfyh a.active:where(.svelte-12qhfyh){background:var(--accent-soft);color:var(--accent)}.status.svelte-12qhfyh{color:var(--text-dim);align-items:center;gap:6px;margin-left:auto;display:inline-flex}.status-text.error.svelte-12qhfyh{color:var(--danger)}.dot.svelte-12qhfyh{background:var(--text-faint);border-radius:50%;width:7px;height:7px}.dot.ok.svelte-12qhfyh{background:var(--ok)}.dot.bad.svelte-12qhfyh{background:var(--danger)}.dot.saving.svelte-12qhfyh{background:var(--accent);animation:.8s ease-in-out infinite svelte-12qhfyh-pulse}@keyframes svelte-12qhfyh-pulse{0%,to{opacity:.35}50%{opacity:1}}.notice.svelte-12qhfyh{background:var(--panel);border:1px solid var(--border);border-radius:var(--radius);color:var(--text-dim);margin:24px;padding:12px 16px}.issue-banner.svelte-12qhfyh{background:color-mix(in srgb, var(--danger) 14%, var(--panel));border-bottom:1px solid var(--danger);color:var(--text);flex-direction:column;gap:4px;padding:8px 16px;display:flex}code.svelte-12qhfyh{background:var(--panel-raised);border-radius:4px;padding:1px 5px}

package/build/client/_app/immutable/assets/3.JwgtcTEd.css

@@ -1 +0,0 @@
-.manifest-selector.svelte-151zph4{flex-direction:column;gap:4px;width:100%;display:flex}.manifest-option.svelte-151zph4{border-color:var(--border-soft);width:100%;height:28px;color:var(--text-dim);cursor:pointer;border-radius:4px;align-items:center;gap:7px;padding:2px 7px;display:flex}.manifest-option.svelte-151zph4:hover{border-color:var(--manifest-color);background:color-mix(in srgb, var(--manifest-color) 10%, var(--panel-raised));color:var(--text)}.manifest-option.svelte-151zph4:focus-within{border-color:var(--manifest-color)}.manifest-option.selected.svelte-151zph4{border-color:var(--manifest-color);background:color-mix(in srgb, var(--manifest-color) 20%, var(--panel-raised));color:var(--text)}.manifest-option.passive.svelte-151zph4{border-color:var(--manifest-color);border-style:dashed}input.svelte-151zph4{width:14px;height:14px;accent-color:var(--manifest-color);flex:none;margin:0}.marker.svelte-151zph4{border:1px solid color-mix(in srgb, var(--manifest-color) 70%, var(--border));background:color-mix(in srgb, var(--manifest-color) 24%, var(--panel));border-radius:3px;flex:none;justify-content:center;align-items:center;width:18px;height:18px;font-size:12px;display:inline-flex}.color-dot.svelte-151zph4{background:var(--manifest-color);border-radius:50%;width:8px;height:8px}.name.svelte-151zph4,.via.svelte-151zph4{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.name.svelte-151zph4{font-size:11px;font-weight:500}.via.svelte-151zph4{color:var(--text-faint);margin-left:auto;font-size:9px}.detail.svelte-xy8zsr{flex:1;grid-template-columns:224px 1fr 280px;min-height:0;display:grid}.center.svelte-xy8zsr{flex-direction:column;min-width:0;min-height:0;padding:12px 16px;display:flex}.center.empty.svelte-xy8zsr,.empty.svelte-xy8zsr{color:var(--text-dim);flex:1;justify-content:center;align-items:center;display:flex}.inspector.svelte-xy8zsr{background:var(--panel);border-left:1px solid var(--border);overflow-y:auto}.inspector.svelte-xy8zsr section:where(.svelte-xy8zsr){border-bottom:1px solid var(--border-soft);padding:12px}.inspector.svelte-xy8zsr h2:where(.svelte-xy8zsr){word-break:break-all;margin:0;font-size:13px}.raw.svelte-xy8zsr{color:var(--text-dim);word-break:break-all;margin:4px 0 0}.warning.svelte-xy8zsr{color:var(--warning);margin:8px 0 0;font-size:11px}.hint.svelte-xy8zsr{color:var(--text-faint);margin:0;font-size:11px}.inspector.svelte-xy8zsr h4:where(.svelte-xy8zsr){text-transform:uppercase;letter-spacing:.06em;color:var(--text-faint);margin:8px 0 4px;font-size:10px}.reference-row.svelte-xy8zsr{border-radius:var(--radius);color:var(--text-dim);align-items:center;gap:6px;min-width:0;padding:3px 4px;display:flex}.reference-row.svelte-xy8zsr:hover{background:var(--panel-raised);color:var(--text)}.reference-field.svelte-xy8zsr{color:var(--text-faint);font-size:11px}.reference-arrow.svelte-xy8zsr{color:var(--text-faint);flex:none}.reference-asset.svelte-xy8zsr{color:var(--accent);text-overflow:ellipsis;white-space:nowrap;font-weight:600;overflow:hidden}.rename.svelte-xy8zsr{gap:8px;margin-bottom:8px;display:flex}.rename.svelte-xy8zsr input:where(.svelte-xy8zsr){flex:1;min-width:0}.danger.svelte-xy8zsr{width:100%}

package/build/client/_app/immutable/chunks/CO4RBJfa.js

@@ -1 +0,0 @@
-import{J as e,P as t,Y as n}from"./CNRz3sSw.js";async function r(e){if(!e.ok){let t=`${e.status} ${e.statusText}`;try{let n=await e.json();n.error?.message&&(t=n.error.message)}catch{}throw Error(t)}return await e.json()}async function i(){return r(await fetch(`/api/state`))}async function a(e,t,n,i){let a=new FormData;return a.set(`file`,e),a.set(`type`,t),a.set(`id`,n),a.set(`folder`,i),r(await fetch(`/api/assets`,{method:`POST`,body:a}))}async function o(e){return r(await fetch(`/api/folders`,{method:`POST`,headers:{"Content-Type":`application/json`},body:JSON.stringify({path:e})}))}async function s(e,t){return r(await fetch(`/api/folders/${encodeURIComponent(e)}`,{method:`PATCH`,headers:{"Content-Type":`application/json`},body:JSON.stringify({name:t})}))}async function c(e,t){return r(await fetch(`/api/folders/${encodeURIComponent(e)}`,{method:`PATCH`,headers:{"Content-Type":`application/json`},body:JSON.stringify({parent:t})}))}async function l(e){return r(await fetch(`/api/folders/${encodeURIComponent(e)}`,{method:`DELETE`}))}async function u(e,t){return r(await fetch(`/api/assets/${encodeURIComponent(e)}`,{method:`PATCH`,headers:{"Content-Type":`application/json`},body:JSON.stringify(t)}))}async function d(e,t){return r(await fetch(`/api/assets/move`,{method:`POST`,headers:{"Content-Type":`application/json`},body:JSON.stringify({assetIds:e,folder:t})}))}async function f(e){return r(await fetch(`/api/assets/${encodeURIComponent(e)}`,{method:`DELETE`}))}async function p(e){return r(await fetch(`/api/assets/delete`,{method:`POST`,headers:{"Content-Type":`application/json`},body:JSON.stringify({assetIds:e})}))}async function m(e){return r(await fetch(`/api/manifests`,{method:`POST`,headers:{"Content-Type":`application/json`},body:JSON.stringify({name:e})}))}async function h(e){return r(await fetch(`/api/manifests/${encodeURIComponent(e)}`,{method:`DELETE`}))}async function g(e,t){return r(await fetch(`/api/manifests/${encodeURIComponent(e)}`,{method:`PATCH`,headers:{"Content-Type":`application/json`},body:JSON.stringify(t)}))}var _=new class{#e=Promise.resolve();#t=n(null);get state(){return t(this.#t)}set state(t){e(this.#t,t,!0)}#n=n(!1);get saving(){return t(this.#n)}set saving(t){e(this.#n,t,!0)}#r=n(null);get error(){return t(this.#r)}set error(t){e(this.#r,t,!0)}#i=n(!1);get loaded(){return t(this.#i)}set loaded(t){e(this.#i,t,!0)}async refresh(){try{this.state=await i(),this.error=null}catch(e){this.error=e instanceof Error?e.message:String(e)}finally{this.loaded=!0}}mutate(e){let t=this.#e.then(async()=>{this.saving=!0,this.error=null;try{let t=await e();return this.state=t,t}catch(e){throw this.error=e instanceof Error?e.message:String(e),e}finally{this.saving=!1}});return this.#e=t.then(()=>{},()=>{}),t}get manifestNames(){return Object.keys(this.state?.library.manifests??{}).sort()}manifestAppearance(e){return this.state?.library.manifests[e]??{}}get generalIssues(){return this.state?.issues.filter(e=>e.assetId===void 0).map(e=>e.message)??[]}assetById(e){return this.state?.assets.find(t=>t.id===e)??null}};export{p as a,d as c,g as d,s as f,f as i,c as l,o as n,l as o,a as p,m as r,h as s,_ as t,u};