fundus 0.3.0 → 0.5.0

package/dist/server/library-store.js

@@ -8,7 +8,7 @@ import { existsSync } from 'node:fs';
 import { mkdir, readFile, rename, rm, unlink, writeFile } from 'node:fs/promises';
 import { dirname, extname, join } from 'node:path';
 import { createHash } from 'node:crypto';
-import { assetIdError, collectAllReferences, createEmptyLibrary, folderNameError, folderNameOf, folderOfRawPath, folderPathError, isFolderOrDescendant, joinFolderPath, manifestColorError, manifestEmojiError, parseLibrary, referenceErrors, normalizeFolderPath, parentFolderPath, portableFolderPathKey, rawFilePathError, rawFileNameOfPath, replaceFolderPrefix, manifestNameError, serializeLibrary } from '../core/index.js';
+import { assetIdError, collectAllReferences, canonicalizeParameters, createEmptyLibrary, folderNameError, folderNameOf, folderOfRawPath, folderPathError, isFolderOrDescendant, joinFolderPath, manifestColorError, manifestEmojiError, parseLibrary, referenceErrors, normalizeFolderPath, parentFolderPath, portableFolderPathKey, rawFilePathError, rawFileNameOfPath, replaceFolderPrefix, manifestNameError, serializeLibrary } from '../core/index.js';
 import { manifestModuleFileName } from './codegen.js';
 import { descriptorsByType, serverPluginForType, serverPluginsByType } from './plugins.js';
 import { isProxyFileNameFor } from './processing/processor.js';
@@ -114,9 +114,12 @@ export class LibraryStore {
      * the owning plugin's default parameters. Returns the updated library.
      */
     async ingest(options) {
-        return this.#enqueue(() => this.#ingest(options));
+        return this.createAsset(options);
     }
-    async #ingest(options) {
+    async createAsset(options, prepareParameters) {
+        return this.#enqueue(() => this.#createAsset(options, prepareParameters));
+    }
+    async #createAsset(options, prepareParameters) {
         const idProblem = assetIdError(options.id);
         if (idProblem)
             throw new Error(idProblem);
@@ -131,21 +134,57 @@ export class LibraryStore {
         }
         const folder = options.folder === undefined ? '' : normalizeFolderPath(options.folder);
         this.#requireFolder(library, folder);
+        const manifests = [...new Set(options.manifests ?? [])].sort();
+        for (const manifest of manifests) {
+            if (!Object.hasOwn(library.manifests, manifest)) {
+                throw new Error(`Unknown manifest "${manifest}".`);
+            }
+        }
         const rawDirectory = join(this.#config.rawDir, folder);
         await mkdir(rawDirectory, { recursive: true });
         const storedName = this.#uniqueRawName(sanitizeFileName(options.fileName), folder);
         const storedPath = folder === '' ? storedName : `${folder}/${storedName}`;
-        await writeFile(join(this.#config.rawDir, storedPath), options.bytes);
-        const record = {
-            type: options.type,
-            raw: storedPath,
-            rawHash: sha256Hex(options.bytes),
-            parameters: plugin.descriptor.defaultParameters(plugin.pluginConfig(this.#config)),
-            manifests: []
-        };
-        library.assets[options.id] = record;
-        await this.write(library);
-        return library;
+        const finalPath = join(this.#config.rawDir, storedPath);
+        const temporaryPath = join(rawDirectory, `.fundus-create-${crypto.randomUUID()}.tmp`);
+        let installed = false;
+        try {
+            await writeFile(temporaryPath, options.bytes);
+            let parameters = plugin.descriptor.validateParameters(plugin.descriptor.defaultParameters(plugin.pluginConfig(this.#config)));
+            if (prepareParameters) {
+                parameters = plugin.descriptor.validateParameters(await prepareParameters({ rawPath: temporaryPath, rawFileName: storedName, parameters }));
+            }
+            const record = {
+                type: options.type,
+                raw: storedPath,
+                rawHash: sha256Hex(options.bytes),
+                parameters,
+                manifests
+            };
+            if (options.importSource) {
+                record.importSource = structuredClone(options.importSource);
+                library.version = 2;
+            }
+            library.assets[options.id] = record;
+            // Validate the complete candidate before installing the final raw path.
+            parseLibrary(serializeLibrary(library));
+            await rename(temporaryPath, finalPath);
+            installed = true;
+            await this.write(library);
+            return library;
+        }
+        catch (cause) {
+            const cleanupErrors = [];
+            if (installed)
+                await unlink(finalPath).catch((error) => cleanupErrors.push(error));
+            await unlink(temporaryPath).catch((error) => {
+                if (error.code !== 'ENOENT')
+                    cleanupErrors.push(error);
+            });
+            if (cleanupErrors.length > 0) {
+                throw new AggregateError([cause, ...cleanupErrors], 'Asset creation failed and cleanup was incomplete.');
+            }
+            throw cause;
+        }
     }
     /**
      * Replace one asset's raw file while preserving its identity and authored
@@ -166,6 +205,7 @@ export class LibraryStore {
         }
         const previousRaw = record.raw;
         const previousHash = record.rawHash;
+        const previousSource = record.importSource;
         const folder = folderOfRawPath(previousRaw);
         const previousName = rawFileNameOfPath(previousRaw);
         const storedName = sanitizedName === previousName ? previousName : this.#uniqueRawName(sanitizedName, folder);
@@ -188,11 +228,14 @@ export class LibraryStore {
             replacementInstalled = true;
             record.raw = nextRaw;
             record.rawHash = sha256Hex(options.bytes);
+            delete record.importSource;
             await this.write(library);
         }
         catch (cause) {
             record.raw = previousRaw;
             record.rawHash = previousHash;
+            if (previousSource)
+                record.importSource = previousSource;
             if (replacementInstalled)
                 await unlink(nextPath).catch(() => { });
             if (previousStaged)
@@ -204,6 +247,59 @@ export class LibraryStore {
             await unlink(backupPath).catch(() => { });
         return library;
     }
+    /** CAS-protected replacement used only by a repeatable import source. */
+    async replaceRawFromImportSource(id, bytes, expected, nextSource) {
+        return this.#enqueue(async () => {
+            const library = await this.read();
+            const record = this.#requireAsset(library, id);
+            if (record.raw !== expected.raw ||
+                record.rawHash !== expected.rawHash ||
+                record.type !== expected.type ||
+                !record.importSource ||
+                canonicalizeParameters(record.importSource) !== expected.canonicalSource) {
+                throw new Error('stale-import');
+            }
+            const absolutePath = join(this.#config.rawDir, record.raw);
+            const { verifyStableRawFile } = await import('./raw-reconciliation.js');
+            try {
+                await verifyStableRawFile(absolutePath, expected.rawHash);
+            }
+            catch {
+                throw new Error('stale-import');
+            }
+            const token = crypto.randomUUID();
+            const temporaryPath = `${absolutePath}.fundus-reimport-${token}.tmp`;
+            const backupPath = `${absolutePath}.fundus-reimport-${token}`;
+            const previousHash = record.rawHash;
+            const previousSource = structuredClone(record.importSource);
+            let staged = false;
+            let installed = false;
+            try {
+                await writeFile(temporaryPath, bytes);
+                await rename(absolutePath, backupPath);
+                staged = true;
+                await rename(temporaryPath, absolutePath);
+                installed = true;
+                record.rawHash = sha256Hex(bytes);
+                if (nextSource)
+                    record.importSource = structuredClone(nextSource);
+                await this.write(library);
+            }
+            catch (cause) {
+                record.rawHash = previousHash;
+                record.importSource = previousSource;
+                if (installed)
+                    await unlink(absolutePath).catch(() => { });
+                if (staged)
+                    await rename(backupPath, absolutePath);
+                await unlink(temporaryPath).catch(() => { });
+                throw cause;
+            }
+            if (staged)
+                await unlink(backupPath).catch(() => { });
+            return library;
+        });
+    }
     /** Replace an asset's parameters (validated by the owning plugin). */
     async updateParameters(id, parameters) {
         return this.#enqueue(() => this.#updateParameters(id, parameters));

package/dist/server/operations.d.ts

@@ -2,6 +2,7 @@ import { type FundusStateDto, type PatchAssetRequestDto, type PatchManifestReque
 import type { ResolvedFundusConfig } from './config-loader.js';
 import { LibraryStore, type IngestOptions, type ReplaceRawFileOptions } from './library-store.js';
 import type { ServerPluginRegistry } from './plugins/contract.js';
+import { SourceImporterRegistry } from './importers/registry.js';
 /**
  * The CLI's `--parameters` merge semantics (M7): a SHALLOW merge at the top
  * level onto the current parameters — a nested object value replaces the whole
@@ -17,9 +18,16 @@ export interface AssetChangeOptions {
     /** Replacement for the explicit manifest membership set (declarative). */
     manifests?: string[];
 }
+export interface ImportAssetOptions extends AssetChangeOptions {
+    importer: string;
+    input: unknown;
+    type: string;
+    id: string;
+    folder?: string;
+}
 export declare class FundusOperations {
     #private;
-    constructor(config: ResolvedFundusConfig, registry?: ServerPluginRegistry);
+    constructor(config: ResolvedFundusConfig, registry?: ServerPluginRegistry, importerRegistry?: SourceImporterRegistry);
     get config(): ResolvedFundusConfig;
     get store(): LibraryStore;
     /** Read-only state snapshot, serialized with mutations but never processing or writing. */
@@ -42,6 +50,10 @@ export declare class FundusOperations {
      * rolls the whole ingest back, so a failed ingest leaves nothing behind.
      */
     ingest(options: IngestOptions & AssetChangeOptions): Promise<FundusStateDto>;
+    /** Materialize a source outside the operation queue, then atomically create the asset. */
+    importAsset(options: ImportAssetOptions): Promise<FundusStateDto>;
+    /** Re-materialize a persisted source with record and on-disk CAS protection. */
+    reimportAsset(id: string, input?: unknown): Promise<FundusStateDto>;
     /** Apply a PATCH body: parameters and/or manifests and/or a rename — in that order. */
     patchAsset(id: string, body: PatchAssetRequestDto): Promise<FundusStateDto>;
     moveAsset(id: string, folder: string): Promise<FundusStateDto>;

package/dist/server/operations.js

@@ -6,7 +6,7 @@
  * operation has exactly one implementation and there is no other save path.
  */
 import { join } from 'node:path';
-import { assetIdError, allDeliveredAssetIds, collectAllReferences, compareCodeUnits, computeLibraryMembership, folderOfRawPath, parentFolderPath, portableFolderPathKey, proposeAssetId, rawFileNameOfPath, typesForFileName } from '../core/index.js';
+import { assetIdError, allDeliveredAssetIds, canonicalizeParameters, collectAllReferences, compareCodeUnits, computeLibraryMembership, folderOfRawPath, normalizeFolderPath, parentFolderPath, portableFolderPathKey, proposeAssetId, rawFileNameOfPath, typesForFileName } from '../core/index.js';
 import { LibraryStore } from './library-store.js';
 import { generateManifestModules } from './codegen.js';
 import { descriptorsByType, serverPluginForType, serverPluginsByType } from './plugins.js';
@@ -14,6 +14,8 @@ import { processAssets, readCurrentProxy } from './processing/processor.js';
 import { encodeRelativePathForUrl } from './folder-filesystem.js';
 import { classifyRawDirectory, verifyStableRawFile } from './raw-reconciliation.js';
 import { rawSafetyIssues } from './raw-safety.js';
+import { serverImporters } from './importers.js';
+import { SourceImportError } from './importers/contract.js';
 /**
  * The CLI's `--parameters` merge semantics (M7): a SHALLOW merge at the top
  * level onto the current parameters — a nested object value replaces the whole
@@ -44,12 +46,14 @@ export class FundusOperations {
     #config;
     #registry;
     #store;
+    #importers;
     #operationQueue = Promise.resolve();
     #pipelineQueue = Promise.resolve();
-    constructor(config, registry = serverPluginsByType) {
+    constructor(config, registry = serverPluginsByType, importerRegistry = serverImporters) {
         this.#config = config;
         this.#registry = registry;
         this.#store = new LibraryStore(config, registry);
+        this.#importers = importerRegistry;
     }
     get config() {
         return this.#config;
@@ -198,6 +202,7 @@ export class FundusOperations {
                 record.type = type;
                 record.rawHash = edited.hash;
                 record.parameters = parameters;
+                delete record.importSource;
                 return edited.assetId;
             });
             await this.#store.deleteProxiesOf(result.value);
@@ -217,6 +222,7 @@ export class FundusOperations {
                     throw new Error(`The moved file "${edited.path}" is not compatible with its current ${record.type} type; choose a compatible type and process it.`);
                 }
                 candidate.assets[edited.assetId].rawHash = edited.hash;
+                delete candidate.assets[edited.assetId].importSource;
                 return edited.assetId;
             });
             await this.#store.deleteProxiesOf(result.value);
@@ -233,36 +239,161 @@ export class FundusOperations {
      * rolls the whole ingest back, so a failed ingest leaves nothing behind.
      */
     ingest(options) {
-        return this.#enqueueOperation(() => this.#ingest(options));
+        return this.#enqueueOperation(async () => {
+            const importer = this.#importers.require('file');
+            const input = importer.validateInput({ fileName: options.fileName, bytes: options.bytes });
+            const raw = await importer.importRaw(input, {
+                config: this.#config,
+                fetch: globalThis.fetch
+            });
+            return this.#createImportedAsset(raw, options);
+        });
     }
-    async #ingest(options) {
-        let library = await this.#store.ingest(options);
-        try {
-            const plugin = serverPluginForType(options.type, this.#registry);
+    /** Materialize a source outside the operation queue, then atomically create the asset. */
+    async importAsset(options) {
+        const preflight = await this.#enqueueOperation(async () => {
+            const library = await this.#store.read();
+            this.#validateImportTarget(options, library);
+            if (Object.hasOwn(library.assets, options.id)) {
+                throw new SourceImportError('invalid-input', `An asset with id "${options.id}" already exists.`);
+            }
+            const importer = this.#importers.require(options.importer);
+            return { importer, input: importer.validateInput(options.input) };
+        });
+        const raw = await preflight.importer.importRaw(preflight.input, {
+            config: this.#config,
+            fetch: globalThis.fetch
+        });
+        return this.#enqueueOperation(async () => {
+            this.#validateImportedRaw(raw, options.importer);
+            return this.#createImportedAsset(raw, options);
+        });
+    }
+    /** Re-materialize a persisted source with record and on-disk CAS protection. */
+    async reimportAsset(id, input) {
+        const snapshot = await this.#enqueueOperation(async () => {
+            const library = await this.#store.read();
+            this.#requireAsset(library, id);
+            const record = library.assets[id];
+            if (!record.importSource) {
+                throw new SourceImportError('invalid-input', `Asset "${id}" has no repeatable import source.`);
+            }
+            const resolved = this.#importers.requireReimport(record.importSource);
+            try {
+                await verifyStableRawFile(join(this.#config.rawDir, record.raw), record.rawHash);
+            }
+            catch {
+                throw new SourceImportError('stale-import', 'The local raw file changed. Apply or discard that edit before re-importing.');
+            }
+            return {
+                importer: resolved.importer,
+                parameters: resolved.parameters,
+                input: input === undefined ? undefined : resolved.importer.validateInput(input),
+                expected: {
+                    raw: record.raw,
+                    rawHash: record.rawHash,
+                    type: record.type,
+                    canonicalSource: canonicalizeParameters(record.importSource)
+                }
+            };
+        });
+        const context = { config: this.#config, fetch: globalThis.fetch };
+        const raw = snapshot.input === undefined
+            ? await snapshot.importer.reimportRaw(snapshot.parameters, context)
+            : await snapshot.importer.importRaw(snapshot.input, context);
+        if (snapshot.input !== undefined && !raw.importSource) {
+            throw new SourceImportError('invalid-response', 'The source importer did not return provenance for the updated source.');
+        }
+        return this.#enqueueOperation(async () => {
+            this.#validateImportedRaw(raw, snapshot.importer.kind);
+            const plugin = serverPluginForType(snapshot.expected.type, this.#registry);
+            if (!plugin.descriptor.accepts.includes(raw.extension)) {
+                throw new SourceImportError('invalid-response', `The ${snapshot.expected.type} type does not accept ".${raw.extension}" files.`);
+            }
+            let library;
+            try {
+                library = await this.#store.replaceRawFromImportSource(id, raw.bytes, snapshot.expected, raw.importSource);
+            }
+            catch (cause) {
+                if (cause instanceof Error && cause.message === 'stale-import') {
+                    throw new SourceImportError('stale-import', 'The asset or local raw file changed while Figma was exporting. Nothing was replaced.');
+                }
+                throw cause;
+            }
+            return this.#afterMutation(library);
+        });
+    }
+    async #createImportedAsset(raw, options) {
+        this.#validateImportedRaw(raw);
+        const fileName = raw.suggestedFileName ?? `${options.id}.${raw.extension}`;
+        const plugin = serverPluginForType(options.type, this.#registry);
+        const library = await this.#store.createAsset({
+            fileName,
+            bytes: raw.bytes,
+            type: options.type,
+            id: options.id,
+            folder: options.folder,
+            manifests: options.manifests,
+            importSource: raw.importSource
+        }, async ({ rawPath, rawFileName, parameters }) => {
+            let next = parameters;
             if (plugin.seedIngestParameters) {
-                const record = library.assets[options.id];
                 const seeded = await plugin.seedIngestParameters({
-                    rawPath: join(this.#config.rawDir, record.raw),
-                    rawFileName: rawFileNameOfPath(record.raw),
-                    parameters: plugin.descriptor.validateParameters(record.parameters),
+                    rawPath,
+                    rawFileName,
+                    parameters: next,
                     config: this.#config
                 });
-                if (seeded !== undefined) {
-                    library = await this.#store.updateParameters(options.id, seeded);
-                }
+                if (seeded !== undefined)
+                    next = seeded;
             }
-            if (options.parametersPatch !== undefined || options.manifests !== undefined) {
-                library = await this.#applyAssetChanges(library, options.id, {
-                    parametersPatch: options.parametersPatch,
-                    manifests: options.manifests
-                });
+            if (options.parametersPatch !== undefined) {
+                next = mergeParameterPatch(next, options.parametersPatch);
+            }
+            return plugin.descriptor.validateParameters(next);
+        });
+        return this.#afterMutation(library);
+    }
+    #validateImportTarget(options, library) {
+        if (typeof options.importer !== 'string' ||
+            typeof options.id !== 'string' ||
+            typeof options.type !== 'string') {
+            throw new SourceImportError('invalid-input', 'Import requires importer, type, and id strings.');
+        }
+        const problem = assetIdError(options.id);
+        if (problem)
+            throw new SourceImportError('invalid-input', problem);
+        serverPluginForType(options.type, this.#registry);
+        if (options.folder !== undefined && typeof options.folder !== 'string') {
+            throw new SourceImportError('invalid-input', 'Import folder must be a string.');
+        }
+        const folder = normalizeFolderPath(options.folder ?? '');
+        if (folder !== '' && !library.folders.includes(folder)) {
+            throw new SourceImportError('invalid-input', `Unknown folder "${folder}".`);
+        }
+        if (options.manifests !== undefined &&
+            (!Array.isArray(options.manifests) ||
+                options.manifests.some((value) => typeof value !== 'string'))) {
+            throw new SourceImportError('invalid-input', 'Import manifests must be an array of strings.');
+        }
+        for (const manifest of new Set(options.manifests ?? [])) {
+            if (!Object.hasOwn(library.manifests, manifest)) {
+                throw new SourceImportError('invalid-input', `Unknown manifest "${manifest}".`);
             }
         }
-        catch (cause) {
-            await this.#store.deleteAsset(options.id);
-            throw cause;
+    }
+    #validateImportedRaw(raw, importerKind) {
+        if (!(raw.bytes instanceof Uint8Array) || !/^[a-z0-9]+$/.test(raw.extension)) {
+            throw new SourceImportError('invalid-response', 'The source importer returned invalid raw data.');
+        }
+        if (raw.importSource) {
+            if (importerKind && raw.importSource.importer !== importerKind) {
+                throw new SourceImportError('invalid-response', 'The source importer returned mismatched provenance.');
+            }
+            this.#importers
+                .require(raw.importSource.importer)
+                .validateSourceParameters(raw.importSource.parameters);
         }
-        return this.#afterMutation(library);
     }
     /** Apply a PATCH body: parameters and/or manifests and/or a rename — in that order. */
     patchAsset(id, body) {
@@ -546,6 +677,9 @@ export class FundusOperations {
                 warnings.push('In no manifest and not referenced by any delivered asset — ' +
                     'nothing is processed or generated for it.');
             }
+            if (record.importSource && !this.#importers.has(record.importSource.importer)) {
+                warnings.push(`Importer "${record.importSource.importer}" is unavailable; the local raw file remains usable.`);
+            }
             let proxy = null;
             if (delivered.has(assetId)) {
                 try {
@@ -572,6 +706,7 @@ export class FundusOperations {
                 folder: folderOfRawPath(record.raw),
                 rawUrl: `/files/raw/${encodeRelativePathForUrl(record.raw)}?v=${record.rawHash.slice(0, 12)}`,
                 rawHash: record.rawHash,
+                importSource: record.importSource,
                 parameters: record.parameters,
                 manifests: record.manifests,
                 passiveManifests: passiveManifestsByAsset.get(assetId) ?? [],
@@ -614,6 +749,7 @@ export class FundusOperations {
         return {
             library,
             assets,
+            importDefaults: { figma: { scale: this.#config.import.figma.defaults.scale } },
             issues,
             presetNames,
             manifestMemberships,

package/package.json

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

package/build/client/_app/immutable/assets/2.AA5XNK5k.css

@@ -1 +0,0 @@
-.context-menu.svelte-109nkvw{z-index:200;background:var(--panel-raised);border:1px solid var(--border);border-radius:6px;width:168px;padding:4px;position:fixed;box-shadow:0 8px 24px #00000073}button.svelte-109nkvw{width:100%;color:var(--text);font:inherit;text-align:left;background:0 0;border:0;border-radius:4px;padding:6px 8px}button.svelte-109nkvw:hover,button.svelte-109nkvw:focus-visible{background:var(--accent-soft);outline:none}button.danger.svelte-109nkvw{color:var(--danger)}hr.svelte-109nkvw{background:var(--border);border:0;height:1px;margin:4px 8px}.manifest-label.svelte-1b4m5oj{align-items:center;gap:4px;min-width:0;display:inline-flex}.emoji.svelte-1b4m5oj{flex:none;line-height:1}.name.svelte-1b4m5oj{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.chip.svelte-1b4m5oj{background:color-mix(in srgb, var(--manifest-color) 20%, transparent);color:var(--manifest-color);border-radius:4px;padding:0 5px;font-size:10px}.chip.passive.svelte-1b4m5oj{border:1px dashed var(--manifest-color);background:0 0}.library-view.svelte-1uha8ag{flex:1;min-height:0;display:flex}.page.svelte-1uha8ag{flex:1;min-height:0;padding:16px;position:relative;overflow-y:auto}.selection-bar.svelte-1uha8ag,.filter-bar.svelte-1uha8ag{flex-wrap:wrap;align-items:center;gap:8px;display:flex}.selection-bar.svelte-1uha8ag{margin-bottom:8px}.filter-bar.svelte-1uha8ag{margin-bottom:16px}.selection-summary.svelte-1uha8ag{color:var(--accent);white-space:nowrap;font-weight:600}.toggle.svelte-1uha8ag{color:var(--text-dim);align-items:center;gap:6px;display:inline-flex}.search.svelte-1uha8ag{align-items:center;gap:5px;width:220px;padding:0 6px;display:flex}.search.svelte-1uha8ag:focus-within{border-color:var(--accent)}.search-icon.svelte-1uha8ag{fill:none;width:14px;height:14px;stroke:var(--text-faint);stroke-width:1.5px;stroke-linecap:round;flex:none}.search-input.svelte-1uha8ag{min-width:0;height:100%;color:var(--text);font:inherit;background:0 0;border:0;outline:none;flex:1;padding:0}.search.svelte-1uha8ag kbd:where(.svelte-1uha8ag){border:1px solid var(--border);color:var(--text-faint);border-radius:3px;flex:none;padding:1px 4px;font:9px/14px system-ui,sans-serif}.import.svelte-1uha8ag{background:var(--accent);color:var(--text);margin-left:auto}.section.svelte-1uha8ag{margin-bottom:24px}.section.svelte-1uha8ag:last-child{margin-bottom:0}.section-emoji.svelte-1uha8ag{margin-right:6px}.grid.svelte-1uha8ag,.folder-grid.svelte-1uha8ag{grid-template-columns:repeat(auto-fill,minmax(160px,1fr));gap:8px;display:grid}.folder-card.svelte-1uha8ag{background:var(--panel);border:1px solid var(--border-soft);min-width:0;height:60px;color:var(--text);text-align:left;border-radius:8px;align-items:center;gap:10px;padding:8px 10px;display:flex}.folder-card.svelte-1uha8ag:hover,.folder-card.svelte-1uha8ag:focus-visible{border-color:var(--accent);outline:none}.folder-card.drop-target.svelte-1uha8ag{border-color:var(--accent);background:var(--accent-soft);box-shadow:0 0 0 1px var(--accent)}.folder-card.dragging-folder.svelte-1uha8ag{opacity:.55}.folder-card-icon.svelte-1uha8ag{color:var(--text-dim);flex:none;align-items:center;display:flex}.folder-card-details.svelte-1uha8ag{flex-direction:column;flex:1;gap:2px;min-width:0;display:flex}.folder-card-details.svelte-1uha8ag strong:where(.svelte-1uha8ag){text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.folder-card-details.svelte-1uha8ag span:where(.svelte-1uha8ag),.folder-card-arrow.svelte-1uha8ag{color:var(--text-faint)}.folder-card-arrow.svelte-1uha8ag{flex:none;font-size:18px}.card.svelte-1uha8ag{background:var(--panel);border:1px solid var(--border-soft);border-radius:8px;flex-direction:column;gap:8px;padding:8px;display:flex;position:relative}.card.selected.svelte-1uha8ag{border-color:var(--accent);box-shadow:0 0 0 1px var(--accent)}.asset-select.svelte-1uha8ag{z-index:1;width:16px;height:16px;accent-color:var(--accent);position:absolute;top:12px;left:12px}.card.svelte-1uha8ag:hover{border-color:var(--accent)}.thumbnail.svelte-1uha8ag{border-radius:var(--radius);justify-content:center;align-items:center;height:96px;display:flex;overflow:hidden}.meta.svelte-1uha8ag{align-items:center;gap:6px;min-width:0;display:flex}.id.svelte-1uha8ag{text-overflow:ellipsis;white-space:nowrap;font-weight:600;overflow:hidden}.type-badge.svelte-1uha8ag{color:var(--text-dim);border:1px solid var(--border);border-radius:4px;flex:none;margin-left:auto;padding:0 5px;font-size:10px}.badges.svelte-1uha8ag{flex-wrap:wrap;gap:4px;min-height:16px;display:flex}.badge.svelte-1uha8ag{border-radius:4px;padding:0 5px;font-size:10px}.badge.warning.svelte-1uha8ag{background:var(--warning-soft);color:var(--warning)}.empty.svelte-1uha8ag{color:var(--text-dim);text-align:center;padding:48px}.dialog-row.svelte-1uha8ag{align-items:center;gap:8px;display:flex}.dialog-row.svelte-1uha8ag span:where(.svelte-1uha8ag){width:44px;color:var(--text-dim)}.dialog-row.svelte-1uha8ag input:where(.svelte-1uha8ag){flex:1}.dialog-text.svelte-1uha8ag,.dialog-warning.svelte-1uha8ag{margin:8px 0 0}.dialog-warning.svelte-1uha8ag{color:var(--warning)}.drop-hint.svelte-1uha8ag{border:2px dashed var(--accent);color:var(--accent);pointer-events:none;background:#0d99ff14;border-radius:12px;justify-content:center;align-items:center;font-size:14px;display:flex;position:fixed;inset:48px 8px 8px}