fundus 0.15.0 → 0.17.0

package/dist/server/library-store.js

@@ -8,8 +8,8 @@ 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, 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 { assetIdError, canonicalizeParameters, createEmptyLibrary, flatLibraryIssues, folderNameError, folderNameOf, folderOfRawPath, folderPathError, isFolderOrDescendant, joinFolderPath, manifestColorError, manifestEmojiError, parseLibrary, normalizeFolderPath, parentFolderPath, portableFolderPathKey, rawFilePathError, rawFileNameOfPath, replaceFolderPrefix, manifestNameError, serializeLibrary } from '../core/index.js';
+import { manifestModuleCollisionIssues, manifestModuleFileName } from './codegen.js';
 import { descriptorsByType, serverPluginForType, serverPluginsByType } from './plugins.js';
 import { isProxyFileNameFor } from './processing/processor.js';
 import { ensureManagedFolder, listRelativeFiles, syncManagedFolders } from './folder-filesystem.js';
@@ -135,8 +135,9 @@ export class LibraryStore {
         const folder = options.folder === undefined ? '' : normalizeFolderPath(options.folder);
         this.#requireFolder(library, folder);
         const manifests = [...new Set(options.manifests ?? [])].sort();
+        const validManifests = this.#validManifestNames(library);
         for (const manifest of manifests) {
-            if (!Object.hasOwn(library.manifests, manifest)) {
+            if (!validManifests.has(manifest)) {
                 throw new Error(`Unknown manifest "${manifest}".`);
             }
         }
@@ -149,9 +150,15 @@ export class LibraryStore {
         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 }));
+            let parameters;
+            if (options.parametersOverride !== undefined) {
+                parameters = options.parametersOverride;
+            }
+            else {
+                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,
@@ -341,6 +348,85 @@ export class LibraryStore {
             return library;
         });
     }
+    /**
+     * CAS-protected raw swap for a Figma tag source that may also rename the
+     * asset. In tag mode the tag IS the id, so changing the tag moves the library
+     * key. The raw swap and the (optional) key move happen in ONE queued critical
+     * section and ONE `write`, so no inconsistent intermediate state is ever
+     * persisted; on any error the record and raw file are rolled back and the key
+     * move (in-memory only until `write`) is discarded.
+     */
+    async repointTagAsset(oldId, newId, bytes, expected, nextSource, updateParameters) {
+        return this.#enqueue(async () => {
+            const library = await this.read();
+            const record = this.#requireAsset(library, oldId);
+            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 renamed = newId !== oldId;
+            if (renamed && Object.hasOwn(library.assets, newId)) {
+                throw new Error(`An asset with id "${newId}" already exists.`);
+            }
+            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-retag-${token}.tmp`;
+            const backupPath = `${absolutePath}.fundus-retag-${token}`;
+            const previousHash = record.rawHash;
+            const previousSource = structuredClone(record.importSource);
+            const previousParameters = structuredClone(record.parameters);
+            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);
+                if (updateParameters)
+                    record.parameters = updateParameters(record.parameters);
+                if (renamed) {
+                    delete library.assets[oldId];
+                    library.assets[newId] = record;
+                }
+                await this.write(library);
+            }
+            catch (cause) {
+                record.rawHash = previousHash;
+                record.importSource = previousSource;
+                record.parameters = previousParameters;
+                if (renamed) {
+                    delete library.assets[newId];
+                    library.assets[oldId] = record;
+                }
+                if (installed)
+                    await unlink(absolutePath).catch(() => { });
+                if (staged)
+                    await rename(backupPath, absolutePath);
+                await unlink(temporaryPath).catch(() => { });
+                throw cause;
+            }
+            if (staged)
+                await unlink(backupPath).catch(() => { });
+            // The old id's proxies are orphans after a rename (pruning also covers it).
+            if (renamed)
+                await this.#deleteProxiesOf(oldId);
+            return library;
+        });
+    }
     /** Replace an asset's parameters (validated by the owning plugin). */
     async updateParameters(id, parameters) {
         return this.#enqueue(() => this.#updateParameters(id, parameters));
@@ -360,8 +446,9 @@ export class LibraryStore {
         const library = await this.read();
         const record = this.#requireAsset(library, id);
         const unique = [...new Set(manifests)];
+        const validManifests = this.#validManifestNames(library);
         for (const name of unique) {
-            if (!Object.hasOwn(library.manifests, name)) {
+            if (!validManifests.has(name)) {
                 throw new Error(`Unknown manifest "${name}".`);
             }
         }
@@ -815,7 +902,14 @@ export class LibraryStore {
      * type, dangling raw pointer, invalid parameters, unknown manifest names,
      * and reference errors (dangling target, type mismatch, cycles).
      */
-    async validate(library) {
+    async validate(library, options = {}) {
+        // The default preserves single-root behaviour (host === effective). When
+        // merging Packages, disk/host checks run on the host library with
+        // `flatSpace: false`, while the flat-space checks (id/type/parameters/
+        // membership/appearance/references) run separately over the *effective*
+        // library — host override records store partial parameters that only
+        // validate once merged, and references may cross the host/Package boundary.
+        const flatSpace = options.flatSpace ?? true;
         const issues = [];
         const folderKeys = new Map();
         for (const folder of library.folders) {
@@ -845,53 +939,7 @@ export class LibraryStore {
                 }
             }
         }
-        for (const [name, record] of Object.entries(library.manifests)) {
-            const nameProblem = manifestNameError(name);
-            if (nameProblem)
-                issues.push({ message: nameProblem });
-            if (record.color !== undefined) {
-                const colorProblem = manifestColorError(record.color);
-                if (colorProblem)
-                    issues.push({ message: `Manifest "${name}": ${colorProblem}` });
-            }
-            if (record.emoji !== undefined) {
-                const emojiProblem = manifestEmojiError(record.emoji);
-                if (emojiProblem)
-                    issues.push({ message: `Manifest "${name}": ${emojiProblem}` });
-            }
-        }
-        const namesByModuleFile = new Map();
-        for (const name of Object.keys(library.manifests)) {
-            const fileName = manifestModuleFileName(name);
-            const existingName = namesByModuleFile.get(fileName);
-            if (existingName !== undefined) {
-                issues.push({
-                    message: `Manifests "${existingName}" and "${name}" would both generate "${fileName}".`
-                });
-            }
-            else {
-                namesByModuleFile.set(fileName, name);
-            }
-        }
         for (const [assetId, record] of Object.entries(library.assets)) {
-            const idProblem = assetIdError(assetId);
-            if (idProblem)
-                issues.push({ assetId, message: idProblem });
-            const plugin = this.#registry[record.type];
-            if (!plugin) {
-                issues.push({ assetId, message: `Unknown asset type "${record.type}".` });
-            }
-            else {
-                try {
-                    plugin.descriptor.validateParameters(record.parameters);
-                }
-                catch (cause) {
-                    issues.push({
-                        assetId,
-                        message: `Invalid parameters: ${cause instanceof Error ? cause.message : String(cause)}`
-                    });
-                }
-            }
             try {
                 assertSafeRelativeFilePath(record.raw);
             }
@@ -911,13 +959,11 @@ export class LibraryStore {
                     message: `Raw file "${record.raw}" is missing from the raw directory.`
                 });
             }
-            for (const manifest of record.manifests) {
-                if (!library.manifests[manifest]) {
-                    issues.push({ assetId, message: `Unknown manifest "${manifest}".` });
-                }
-            }
         }
-        issues.push(...referenceErrors(library, collectAllReferences(library, descriptorsByType(this.#registry))));
+        if (flatSpace) {
+            issues.push(...flatLibraryIssues(library, descriptorsByType(this.#registry)));
+            issues.push(...manifestModuleCollisionIssues(library.manifests));
+        }
         return issues;
     }
     async #deleteProxiesOf(assetId) {
@@ -940,6 +986,21 @@ export class LibraryStore {
         }
         return library.assets[id];
     }
+    /**
+     * Valid manifest names for asset membership: the host library's own manifests
+     * plus any a configured Package introduces. The effective (merged) library
+     * unions both, so a host asset (or slot fill) may be placed into a
+     * Package-introduced manifest — validating against the host manifests alone
+     * would wrongly reject that placement.
+     */
+    #validManifestNames(library) {
+        const names = new Set(Object.keys(library.manifests));
+        for (const pkg of this.#config.packages ?? []) {
+            for (const name of Object.keys(pkg.declaration.manifests))
+                names.add(name);
+        }
+        return names;
+    }
     /** Resolve a non-colliding raw file name, appending `-1`, `-2`, … before the extension. */
     #uniqueRawName(fileName, folder) {
         if (!existsSync(join(this.#config.rawDir, folder, fileName)))

package/dist/server/operations.d.ts

@@ -66,6 +66,18 @@ export declare class FundusOperations {
     reimportAsset(id: string, input?: unknown): Promise<FundusStateDto>;
     /** Materialize a new source, then atomically replace an existing asset's raw file. */
     replaceRawFromSource(id: string, options: ReplaceRawFromSourceOptions): Promise<FundusStateDto>;
+    /**
+     * Edit a Figma tag asset's tag, fileKey, and/or scale in place. Because in tag
+     * mode the tag IS the asset id, changing the tag renames the asset (moves the
+     * library key); changing only fileKey/scale is an in-place re-point. Mirrors
+     * `reimportAsset`'s three phases: preflight in the queue, materialize outside
+     * it, then commit atomically through `store.repointTagAsset`.
+     */
+    retagFigmaAsset(id: string, input: {
+        tag?: string;
+        fileKey?: string;
+        scale?: 1 | 2 | 3 | 4;
+    }): 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>;