fundus 0.26.0 → 0.28.0

package/dist/core/figma-tag-script.js

@@ -121,20 +121,32 @@ export async function loadTaggableNode(figma, nodeId) {
     return node;
 }
 /**
- * The first other node carrying `tag`, across every page. Scripts start with
- * only the first page loaded, and `findAll` on an unloaded page silently
- * misses content, so each page is loaded first.
+ * Every other node carrying `tag`, across every page. Scripts start with only
+ * the first page loaded, and `findAll` on an unloaded page silently misses
+ * content, so each page is loaded first.
  */
-export async function findTagHolder(figma, tag, exceptNodeId) {
+export async function findTagHolders(figma, tag, exceptNodeId) {
+    const holders = [];
     for (const page of figma.root.children) {
         await page.loadAsync();
-        const [holder] = page.findAll((candidate) => candidate.id !== exceptNodeId &&
+        const found = page.findAll((candidate) => candidate.id !== exceptNodeId &&
             !isInstanceSublayerId(candidate.id) &&
             candidate.getSharedPluginData(FIGMA_TAG_NAMESPACE, FIGMA_TAG_KEY) === tag);
-        if (holder)
-            return { node: holder, page };
+        for (const node of found)
+            holders.push({ node, page });
     }
-    return null;
+    return holders;
+}
+/** Clear the node's tag and its Fundus annotation; returns whether an annotation was removed. */
+export function clearFundusTag(node) {
+    node.setSharedPluginData(FIGMA_TAG_NAMESPACE, FIGMA_TAG_KEY, '');
+    if (!supportsAnnotations(node)) {
+        node.setSharedPluginData(FIGMA_TAG_NAMESPACE, FIGMA_ANNOTATION_LABEL_KEY, '');
+        return false;
+    }
+    const before = node.annotations.length;
+    stripFundusAnnotation(node);
+    return node.annotations.length < before;
 }
 /**
  * Tag a node, re-checking the live document right before writing: the CLI's
@@ -149,10 +161,13 @@ export async function setFundusTag(figma, input) {
     if (!input.force && previous !== '') {
         throw new Error(`Node "${node.name}" (${node.id}) already carries tag "${previous}"; rerun prepare-set-tag with --force to replace it.`);
     }
-    const holder = await findTagHolder(figma, input.tag, node.id);
-    if (holder) {
-        throw new Error(`Tag "${input.tag}" is already used by "${holder.node.name}" (${holder.node.id}) on page "${holder.page.name}"; choose another tag.`);
+    const holders = await findTagHolders(figma, input.tag, node.id);
+    if (!input.force && holders.length > 0) {
+        const [holder] = holders;
+        throw new Error(`Tag "${input.tag}" is already used by "${holder.node.name}" (${holder.node.id}) on page "${holder.page.name}"; choose another tag, or rerun prepare-set-tag with --force to move it here.`);
     }
+    for (const holder of holders)
+        clearFundusTag(holder.node);
     node.setSharedPluginData(FIGMA_TAG_NAMESPACE, FIGMA_TAG_KEY, input.tag);
     const annotated = supportsAnnotations(node);
     if (annotated)
@@ -163,7 +178,12 @@ export async function setFundusTag(figma, input) {
         nodeName: node.name,
         tag: input.tag,
         previousTag: previous === '' ? null : previous,
-        annotated
+        annotated,
+        movedFrom: holders.map((holder) => ({
+            nodeId: holder.node.id,
+            nodeName: holder.node.name,
+            page: holder.page.name
+        }))
     };
 }
 export async function deleteFundusTag(figma, input) {
@@ -174,16 +194,7 @@ export async function deleteFundusTag(figma, input) {
             ? `Node "${node.name}" (${node.id}) carries no Fundus tag.`
             : `Node "${node.name}" (${node.id}) carries tag "${current}", not "${input.tag}"; rerun prepare-delete-tag.`);
     }
-    node.setSharedPluginData(FIGMA_TAG_NAMESPACE, FIGMA_TAG_KEY, '');
-    let annotationRemoved = false;
-    if (supportsAnnotations(node)) {
-        const before = node.annotations.length;
-        stripFundusAnnotation(node);
-        annotationRemoved = node.annotations.length < before;
-    }
-    else {
-        node.setSharedPluginData(FIGMA_TAG_NAMESPACE, FIGMA_ANNOTATION_LABEL_KEY, '');
-    }
+    const annotationRemoved = clearFundusTag(node);
     return {
         ok: true,
         nodeId: node.id,
@@ -208,7 +219,8 @@ const SCRIPT_FUNCTIONS = [
     stripFundusAnnotation,
     pageOfNode,
     loadTaggableNode,
-    findTagHolder,
+    findTagHolders,
+    clearFundusTag,
     setFundusTag,
     deleteFundusTag
 ];

package/dist/core/index.d.ts

@@ -3,7 +3,7 @@ export { createEmptyLibrary, parseLibrary, serializeLibrary } from './library.js
 export { rawFileNameError, rawFilePathError, portableRawPathKey, isFundusTransactionName } from './raw-path.js';
 export { ROOT_FOLDER, FOLDER_SENTINEL, folderNameError, folderPathError, normalizeFolderPath, portableFolderPathKey, parentFolderPath, folderNameOf, joinFolderPath, folderOfRawPath, rawFileNameOfPath, isFolderOrDescendant, replaceFolderPrefix } from './folder-path.js';
 export { RESERVED_ASSET_IDS, isValidAssetId, assetIdError, manifestNameError } from './asset-id.js';
-export type { SetFigmaTagInput, SetFigmaTagResult, DeleteFigmaTagInput, DeleteFigmaTagResult } from './figma-tag-script.js';
+export type { SetFigmaTagInput, SetFigmaTagResult, FigmaTagHolder, DeleteFigmaTagInput, DeleteFigmaTagResult } from './figma-tag-script.js';
 export { buildSetTagScript, buildDeleteTagScript, isInstanceSublayerId } from './figma-tag-script.js';
 export type { ManifestColor } from './manifest-appearance.js';
 export { MANIFEST_COLORS, MANIFEST_EMOJIS, isManifestColor, isManifestEmoji, resolveManifestColor, manifestColorError, manifestEmojiError } from './manifest-appearance.js';
@@ -31,7 +31,7 @@ export type { AssetTypePluginDescriptor } from './plugins/contract.js';
 export type { ImageFormat, ImagePreset, ImagePluginConfig, ImageParameters } from './plugins/image.js';
 export { imagePlugin, validateImagePreset, IMAGE_BUILT_IN_PRESETS, RASTER_IMAGE_EXTENSIONS } from './plugins/image.js';
 export type { SliceCompression, SliceParameters, SlicePluginConfig } from './plugins/slice.js';
-export { processedSliceInsets, slicePlugin, SLICE_BUILT_IN_PRESETS } from './plugins/slice.js';
+export { processedSliceInsets, sliceEntryGeometry, slicePlugin, SLICE_BUILT_IN_PRESETS } from './plugins/slice.js';
 export type { CustomFfmpegVideoPreset, FfmpegArgument, FfmpegArgumentTokens, FfmpegCommandPaths, FfmpegPathToken, ResolvedCustomFfmpegVideoPreset, ResolvedVideoPreset, StructuredVideoPreset, VideoPreset, VideoPluginConfig, VideoParameters } from './plugins/video.js';
 export { isCustomFfmpegVideoPreset, materializeFfmpegCommand, videoPlugin, validateVideoPreset, validateVideoParameters, VIDEO_BUILT_IN_PRESETS, VIDEO_EXTENSIONS } from './plugins/video.js';
 export type { ChromaKeyVideoParameters } from './plugins/chroma-key-video.js';

package/dist/core/index.js

@@ -15,7 +15,7 @@ export { isAssetReference } from './asset-reference.js';
 export { collectAllReferences, referenceErrors, referenceClosure, topologicalReferenceOrder } from './reference-graph.js';
 export { computeLibraryMembership, allDeliveredAssetIds } from './manifest-membership.js';
 export { imagePlugin, validateImagePreset, IMAGE_BUILT_IN_PRESETS, RASTER_IMAGE_EXTENSIONS } from './plugins/image.js';
-export { processedSliceInsets, slicePlugin, SLICE_BUILT_IN_PRESETS } from './plugins/slice.js';
+export { processedSliceInsets, sliceEntryGeometry, slicePlugin, SLICE_BUILT_IN_PRESETS } from './plugins/slice.js';
 export { isCustomFfmpegVideoPreset, materializeFfmpegCommand, videoPlugin, validateVideoPreset, validateVideoParameters, VIDEO_BUILT_IN_PRESETS, VIDEO_EXTENSIONS } from './plugins/video.js';
 export { chromaKeyVideoPlugin } from './plugins/chroma-key-video.js';
 export { audioPlugin, validateAudioPreset, AUDIO_BUILT_IN_PRESETS, AUDIO_EXTENSIONS } from './plugins/audio.js';

package/dist/core/manifest-entry.d.ts

@@ -43,6 +43,13 @@ export interface SliceManifestEntry extends AssetIdentified {
     /** Pixel dimensions of the delivered image the insets are measured in. */
     sourceWidth: number;
     sourceHeight: number;
+    /**
+     * Pixel dimensions before stretch compression; present only when compression
+     * shrank the delivered image. Layout sizing uses these, painting samples the
+     * delivered `sourceWidth` × `sourceHeight`.
+     */
+    uncompressedWidth?: number;
+    uncompressedHeight?: number;
 }
 export interface VideoManifestEntry extends AssetIdentified {
     kind: 'video';

package/dist/core/plugins/slice.d.ts

@@ -5,6 +5,7 @@
  * preset). No `targetWidth`: fixed caps keep their authored source-pixel size.
  */
 import type { AssetTypePluginDescriptor } from './contract.js';
+import type { SliceManifestEntry } from '../manifest-entry.js';
 import { type SliceInsets, type SliceMode } from '../slice-data.js';
 import type { ImagePluginConfig, ImagePreset } from './image.js';
 export interface SliceParameters {
@@ -39,8 +40,19 @@ export declare function processedSliceInsets(options: {
     width: number;
     height: number;
 }): SliceInsets;
+interface Dimensions {
+    width: number;
+    height: number;
+}
+/**
+ * The geometry fields of a slice entry delivered at `delivered` pixels from a
+ * `raw` original — shared by codegen and the editor preview so both describe
+ * the image identically.
+ */
+export declare function sliceEntryGeometry(parameters: SliceParameters, delivered: Dimensions, raw: Dimensions): Pick<SliceManifestEntry, 'slicing' | 'sourceWidth' | 'sourceHeight' | 'uncompressedWidth' | 'uncompressedHeight'>;
 /** Same shape as the image plugin's config: named output-format presets. */
 export type SlicePluginConfig = ImagePluginConfig;
 /** Built-in presets, always available; host config merges over them. */
 export declare const SLICE_BUILT_IN_PRESETS: Record<string, ImagePreset>;
 export declare const slicePlugin: AssetTypePluginDescriptor<SliceParameters, SlicePluginConfig>;
+export {};

package/dist/core/plugins/slice.js

@@ -30,6 +30,32 @@ export function processedSliceInsets(options) {
     const bottom = clamp(desiredBottom, 0, options.height - top);
     return { top, right, bottom, left };
 }
+function hasAnySide(insets) {
+    if (!insets)
+        return false;
+    return insets.top > 0 || insets.right > 0 || insets.bottom > 0 || insets.left > 0;
+}
+/**
+ * The geometry fields of a slice entry delivered at `delivered` pixels from a
+ * `raw` original — shared by codegen and the editor preview so both describe
+ * the image identically.
+ */
+export function sliceEntryGeometry(parameters, delivered, raw) {
+    // Slices are never resized, so differing dimensions mean compression shrank the image.
+    const compressed = delivered.width !== raw.width || delivered.height !== raw.height;
+    return {
+        slicing: {
+            mode: parameters.mode,
+            insets: processedSliceInsets({ ...parameters, ...delivered }),
+            pixelRatio: parameters.pixelRatio,
+            // An all-zero overdraw is semantically "none" — keep the entry minimal.
+            ...(hasAnySide(parameters.overdraw) ? { overdraw: parameters.overdraw } : {})
+        },
+        sourceWidth: delivered.width,
+        sourceHeight: delivered.height,
+        ...(compressed ? { uncompressedWidth: raw.width, uncompressedHeight: raw.height } : {})
+    };
+}
 /** Built-in presets, always available; host config merges over them. */
 // Deliberately separate from image presets: each namespace feeds its own job hash.
 export const SLICE_BUILT_IN_PRESETS = {

package/dist/runtime/chroma-key-gl.d.ts

@@ -6,13 +6,21 @@
  * The keying algorithm follows the upstream shader: the key color and each
  * pixel are converted to YCbCr chroma (Cb/Cr), the squared chroma distance is mapped
  * through a cutoff/feather window (`colorclose`), the resulting mask is blurred with a
- * 3×3 neighbourhood + smoothstep-sharpened, the keyed color is despilled (green pulled
- * toward the red/blue average, lost luminance re-added), and the output is
+ * 3×3 neighbourhood + smoothstep-sharpened, the keyed color is despilled (lost
+ * luminance re-added), and the output is
  * `vec4(color * mask, mask)` — the upstream output formula (tint fixed at white; tinting
  * is host styling, not asset data) — emitted premultiplied (rgb × alpha) for the canvas
  * compositor (see the fragColor note).
  *
- * Fundus adds an optional mask pass (`setMask`): a grayscale image
+ * Fundus replaces the upstream despill, which hard-codes greenscreen (green pulled toward
+ * (2b + r) / 4 — it misses any other key's spill, and tints white and gray pink even for
+ * green keys). Fundus's despill follows the key color: the key's dominant channels
+ * (`spillChannels`) are clamped down to the pixel's strongest remaining channel, so
+ * only excess in the key's direction is removed and neutral colors stay exact. For a
+ * green key that is the classic "clamp g to max(r, b)". `despillCoverage` fades the
+ * despill out over opaque pixels, so artwork colored like the key survives.
+ *
+ * Fundus also adds an optional mask pass (`setMask`): a grayscale image
  * sampled at the same UVs whose luminance multiplies the final alpha — white keeps a
  * pixel, black drops it, gray fades it (no alpha clip). Absent a mask, a 1×1 white
  * fallback texture makes the pass a no-op.
@@ -20,7 +28,7 @@
  * Owns its own GL context on the given canvas. `create` returns null when WebGL2 is
  * unavailable. Browser-only; the caller drives it per frame with the playing <video>.
  */
-import type { ChromaKeyParameters } from '../core/index.js';
+import { type ChromaKeyParameters } from '../core/index.js';
 export declare class ChromaKeyGl {
     #private;
     /** Returns null when WebGL2 is unavailable or the shader fails to compile. */

package/dist/runtime/chroma-key-gl.js

@@ -1,3 +1,34 @@
+/**
+ * WebGL2 chroma-key video renderer based on the public UnityChromakey shader
+ * (https://github.com/otdavies/UnityChromakey, `Shaders/ChromaKey.shader`) so a
+ * greenscreen video plays with a transparent background.
+ *
+ * The keying algorithm follows the upstream shader: the key color and each
+ * pixel are converted to YCbCr chroma (Cb/Cr), the squared chroma distance is mapped
+ * through a cutoff/feather window (`colorclose`), the resulting mask is blurred with a
+ * 3×3 neighbourhood + smoothstep-sharpened, the keyed color is despilled (lost
+ * luminance re-added), and the output is
+ * `vec4(color * mask, mask)` — the upstream output formula (tint fixed at white; tinting
+ * is host styling, not asset data) — emitted premultiplied (rgb × alpha) for the canvas
+ * compositor (see the fragColor note).
+ *
+ * Fundus replaces the upstream despill, which hard-codes greenscreen (green pulled toward
+ * (2b + r) / 4 — it misses any other key's spill, and tints white and gray pink even for
+ * green keys). Fundus's despill follows the key color: the key's dominant channels
+ * (`spillChannels`) are clamped down to the pixel's strongest remaining channel, so
+ * only excess in the key's direction is removed and neutral colors stay exact. For a
+ * green key that is the classic "clamp g to max(r, b)". `despillCoverage` fades the
+ * despill out over opaque pixels, so artwork colored like the key survives.
+ *
+ * Fundus also adds an optional mask pass (`setMask`): a grayscale image
+ * sampled at the same UVs whose luminance multiplies the final alpha — white keeps a
+ * pixel, black drops it, gray fades it (no alpha clip). Absent a mask, a 1×1 white
+ * fallback texture makes the pass a no-op.
+ *
+ * Owns its own GL context on the given canvas. `create` returns null when WebGL2 is
+ * unavailable. Browser-only; the caller drives it per frame with the playing <video>.
+ */
+import { DEFAULT_CHROMA_KEY_PARAMETERS } from '../core/index.js';
 const VERTEX_SHADER = `#version 300 es
 in vec2 a_pos;
 out vec2 v_uv;
@@ -9,8 +40,8 @@ void main() {
 }`;
 // The upstream fragment, translated HLSL → GLSL. Kept structurally identical (same
 // function names, same sample pattern, same constants) so it can be diffed against
-// the original; only the texel-size plumbing differs (u_texelSize is (1/w, 1/h),
-// Unity's _MainTex_TexelSize packs (1/w, 1/h, w, h)).
+// the original; only the texel-size plumbing (u_texelSize is (1/w, 1/h), Unity's
+// _MainTex_TexelSize packs (1/w, 1/h, w, h)) and the despill block differ.
 const FRAGMENT_SHADER = `#version 300 es
 precision highp float;
 
@@ -28,6 +59,8 @@ uniform float u_maskFeathering;
 uniform float u_sharpening;
 uniform float u_despill;
 uniform float u_despillLuminanceAdd;
+uniform vec3 u_spillChannels;
+uniform float u_despillCoverage;
 
 float rgb2y(vec3 c) {
 	return 0.299 * c.r + 0.587 * c.g + 0.114 * c.b;
@@ -85,9 +118,20 @@ void main() {
 	float smoothedMask = smoothstep(u_sharpening, 1.0, mix(c, blurContribution, u_maskFeathering));
 	vec4 result = color * smoothedMask;
 
-	// Despill
-	float v = (2.0 * result.b + result.r) / 4.0;
-	if (result.g > v) result.g = mix(result.g, v, u_despill);
+	// Despill (Fundus, see the header): clamp the spill channels to the strongest other
+	// channel. Non-spill channels read as 1.0 in the min and 0.0 in the max (result is
+	// in 0–1); a key without spill channels has an all-zero mask and subtracts nothing.
+	vec3 spillValues = mix(vec3(1.0), result.rgb, u_spillChannels);
+	vec3 otherValues = result.rgb * (1.0 - u_spillChannels);
+	float spillExcess = max(
+		min(spillValues.r, min(spillValues.g, spillValues.b)) -
+			max(otherValues.r, max(otherValues.g, otherValues.b)),
+		0.0
+	);
+	// Full despill where the mask is at most 0.8 (the keyed edge), coverage-scaled
+	// above it.
+	float coverage = mix(1.0 - smoothstep(0.8, 1.0, smoothedMask), 1.0, u_despillCoverage);
+	result.rgb -= u_spillChannels * spillExcess * u_despill * coverage;
 	vec4 dif = color - result;
 	float desaturatedDif = rgb2y(dif.xyz);
 	result += mix(0.0, desaturatedDif, u_despillLuminanceAdd);
@@ -107,6 +151,15 @@ void main() {
 	// whole canvas rect on iOS.
 	fragColor = vec4(keyed.rgb * keyed.a, keyed.a);
 }`;
+/**
+ * The key color's spill channels as a 0/1 mask: each channel above the key's channel
+ * mean (green → g; magenta → r, b; cyan → g, b). A gray key has none, so no despill.
+ * Compared as 2c > a + b, which is exact for equal channels.
+ */
+function spillChannels(keyColor) {
+    const [r, g, b] = keyColor;
+    return [2 * r > g + b ? 1 : 0, 2 * g > r + b ? 1 : 0, 2 * b > r + g ? 1 : 0];
+}
 function compileProgram(gl) {
     const compile = (type, source) => {
         const shader = gl.createShader(type);
@@ -202,7 +255,9 @@ export class ChromaKeyGl {
             maskFeathering: location('u_maskFeathering'),
             sharpening: location('u_sharpening'),
             despill: location('u_despill'),
-            despillLuminanceAdd: location('u_despillLuminanceAdd')
+            despillLuminanceAdd: location('u_despillLuminanceAdd'),
+            spillChannels: location('u_spillChannels'),
+            despillCoverage: location('u_despillCoverage')
         };
         gl.uniform1i(gl.getUniformLocation(this.#program, 'u_texture'), 0);
         gl.uniform1i(gl.getUniformLocation(this.#program, 'u_mask'), 1);
@@ -280,6 +335,8 @@ export class ChromaKeyGl {
         gl.uniform1f(this.#uniforms.sharpening, parameters.sharpening);
         gl.uniform1f(this.#uniforms.despill, parameters.despill);
         gl.uniform1f(this.#uniforms.despillLuminanceAdd, parameters.despillLuminanceAdd);
+        gl.uniform3fv(this.#uniforms.spillChannels, spillChannels(parameters.keyColor));
+        gl.uniform1f(this.#uniforms.despillCoverage, parameters.despillCoverage ?? DEFAULT_CHROMA_KEY_PARAMETERS.despillCoverage);
         gl.clear(gl.COLOR_BUFFER_BIT);
         gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
     }

package/dist/runtime/components/ChromaKeyVideo.svelte

@@ -103,7 +103,8 @@
 			maskFeathering: key.maskFeathering,
 			sharpening: key.sharpening,
 			despill: key.despill,
-			despillLuminanceAdd: key.despillLuminanceAdd
+			despillLuminanceAdd: key.despillLuminanceAdd,
+			despillCoverage: key.despillCoverage
 		};
 		lifecycle?.setChromaKey(snapshot);
 	});

package/dist/runtime/geometry.d.ts

@@ -27,7 +27,7 @@ import type { SliceInsets, SliceManifestEntry } from '../core/index.js';
  * The manifest-entry fields the pure layout math needs — a structural subset
  * of `SliceManifestEntry`, so hand-built fixtures stay minimal.
  */
-export type SliceLayoutEntry = Pick<SliceManifestEntry, 'sourceWidth' | 'sourceHeight' | 'slicing'>;
+export type SliceLayoutEntry = Pick<SliceManifestEntry, 'sourceWidth' | 'sourceHeight' | 'uncompressedWidth' | 'uncompressedHeight' | 'slicing'>;
 /**
  * The insets that actually apply for the entry's mode: a 3-slice mode zeroes out
  * the axis it does not use (and `one` uses none at all), so callers never have
@@ -53,7 +53,9 @@ export interface SliceLayoutGeometry {
  * image minus its baked-in overdraw, divided by the export `pixelRatio`. The
  * core is what fills the layout box when `Slice` renders the entry; the
  * overdraw band paints outside the box (like a CSS `box-shadow`), so these are
- * the sizes to lay the element out at.
+ * the sizes to lay the element out at. Stretch compression is a delivery
+ * optimization, so the authored `uncompressedWidth` / `uncompressedHeight`
+ * take precedence over the delivered source size.
  *
  * The math is identical for all modes; the mode decides how a consumer should
  * use the result:

package/dist/runtime/geometry.js

@@ -35,15 +35,15 @@ export function effectiveOverdraw(entry) {
     return { top, right, bottom, left };
 }
 /**
- * The layout box — the image minus its effective overdraw — in **source pixels**
- * Never smaller than one source pixel per axis (`effectiveOverdraw` guarantees
- * a remaining box).
+ * The layout box — an image of `width × height` pixels minus the entry's
+ * effective overdraw — in those pixels. Never smaller than one pixel per axis
+ * (`effectiveOverdraw` guarantees a remaining box).
  */
-function sourceLayoutSize(entry) {
+function coreSize(entry, width, height) {
     const overdraw = effectiveOverdraw(entry);
     return {
-        width: Math.max(1, entry.sourceWidth - overdraw.left - overdraw.right),
-        height: Math.max(1, entry.sourceHeight - overdraw.top - overdraw.bottom)
+        width: Math.max(1, width - overdraw.left - overdraw.right),
+        height: Math.max(1, height - overdraw.top - overdraw.bottom)
     };
 }
 /**
@@ -51,7 +51,9 @@ function sourceLayoutSize(entry) {
  * image minus its baked-in overdraw, divided by the export `pixelRatio`. The
  * core is what fills the layout box when `Slice` renders the entry; the
  * overdraw band paints outside the box (like a CSS `box-shadow`), so these are
- * the sizes to lay the element out at.
+ * the sizes to lay the element out at. Stretch compression is a delivery
+ * optimization, so the authored `uncompressedWidth` / `uncompressedHeight`
+ * take precedence over the delivered source size.
  *
  * The math is identical for all modes; the mode decides how a consumer should
  * use the result:
@@ -72,12 +74,12 @@ function sourceLayoutSize(entry) {
  * no float artifacts leak into style output.
  */
 export function sliceLayoutGeometry(entry) {
-    const sourceLayout = sourceLayoutSize(entry);
+    const core = coreSize(entry, entry.uncompressedWidth ?? entry.sourceWidth, entry.uncompressedHeight ?? entry.sourceHeight);
     const pixelRatio = entry.slicing.pixelRatio > 0 ? entry.slicing.pixelRatio : 1;
     return {
-        width: sourceLayout.width / pixelRatio,
-        height: sourceLayout.height / pixelRatio,
-        aspectRatio: `${sourceLayout.width} / ${sourceLayout.height}`
+        width: core.width / pixelRatio,
+        height: core.height / pixelRatio,
+        aspectRatio: `${core.width} / ${core.height}`
     };
 }
 /**
@@ -94,7 +96,7 @@ export function computeOverdrawDestination(entry, boxWidth, boxHeight) {
         return overdraw;
     }
     const pixelRatio = entry.slicing.pixelRatio > 0 ? entry.slicing.pixelRatio : 1;
-    const sourceLayout = sourceLayoutSize(entry);
+    const sourceLayout = coreSize(entry, entry.sourceWidth, entry.sourceHeight);
     let horizontalScale;
     let verticalScale;
     if (entry.slicing.mode === 'three-horizontal') {

package/dist/server/cli-figma-tags.js

@@ -32,16 +32,23 @@ const PREPARE_SET_TAG_HELP = `fundus figma prepare-set-tag — prepare a use_fig
 Usage: fundus figma prepare-set-tag --node-id <id> --tag <tag>
                                     [--file <key|link>] [--force] [--json]
 
-Refuses, listing the file's existing tags, when another node already carries
-the tag or a Fundus asset with that id exists from another source. Refuses
-when the node already carries a tag (the same one or another) unless --force.
+Refuses unless --force, listing the file's existing tags, when another node
+already carries the tag; --force moves the tag (and its annotation) from those
+nodes to this one, so it stays unique. Also refuses unless --force when the
+node already carries a tag (the same one or another) or a Fundus asset with
+that id exists from another source. An asset imported from this very node by
+node id is not a conflict: tagging prepares its move to the tag
+(\`fundus asset replace <tag> --from figma --figma-tag <tag>\` afterwards keeps
+its id, parameters, and manifests).
 
 Flags:
   --node-id <id>      the node to tag: 12:34 or 12-34
   --tag <tag>         the Fundus asset id to store on the node (camelCase)
   --file <key|link>   Figma file key or link; default:
                       import.figma.defaultFileKey from fundus.config.ts
-  --force             replace the node's current tag, or rewrite the same tag
+  --force             always set the tag: replace the node's current tag,
+                      rewrite the same tag, move it from other nodes, or tag
+                      despite a Fundus asset from another source
   --json              print {"ok": true, "fileKey", "nodeId", "tag",
                       "previousTag", "warnings", "next", "code"}; a refusal
                       prints {"ok": false, "error": {"message"}, "existingTags"}
@@ -50,7 +57,7 @@ Flags:
 
 Without --json the script goes to stdout, everything else to stderr.
 The script returns {"ok": true, "nodeId", "nodeName", "tag", "previousTag",
-"annotated"}. Afterwards: \`fundus asset ingest --from figma --figma-tag <tag>\`.
+"annotated", "movedFrom": [{"nodeId", "nodeName", "page"}]}. Afterwards: \`fundus asset ingest --from figma --figma-tag <tag>\`.
 
 Example:
   fundus figma prepare-set-tag --file 'https://www.figma.com/design/abc/UI' \\

package/dist/server/figma-tags.js

@@ -37,6 +37,13 @@ function tagListing(nodes) {
 function describeNode(node) {
     return `"${node.nodeName}" (${node.nodeId}) on page "${node.page}"`;
 }
+/** Whether `record` is a node-mode Figma import of `nodeId` in `fileKey`. */
+function isNodeImportOf(record, fileKey, nodeId) {
+    if (record.importSource?.importer !== 'figma')
+        return false;
+    const source = validateFigmaSourceParameters(record.importSource.parameters);
+    return source.mode !== 'tag' && source.fileKey === fileKey && source.nodeId === nodeId;
+}
 /** The library asset imported from `tag` in `fileKey`, if any. */
 function tagImportedAsset(library, fileKey, tag) {
     const record = library.assets[tag];
@@ -55,12 +62,31 @@ export function planSetFigmaTag(request, { library, document }) {
     const nodes = figmaDocumentNodes(document);
     const existingTags = tagListing(nodes);
     const warnings = [];
-    const holder = nodes.find((node) => node.tag === tag && node.nodeId !== nodeId);
-    if (holder) {
-        throw new FigmaTagConflictError(`Tag "${tag}" is already used by ${describeNode(holder)} — choose another tag (existing tags are listed).`, existingTags);
+    const holders = nodes.filter((node) => node.tag === tag && node.nodeId !== nodeId);
+    if (holders.length > 0) {
+        const described = holders.map(describeNode).join(', ');
+        if (!force) {
+            throw new FigmaTagConflictError(`Tag "${tag}" is already used by ${described} — choose another tag, or pass --force to move it to node ${nodeId} (existing tags are listed).`, existingTags);
+        }
+        warnings.push(`Moves tag "${tag}" from ${described} to node ${nodeId}.`);
     }
-    if (Object.hasOwn(library.assets, tag) && tagImportedAsset(library, fileKey, tag) === null) {
-        throw new FigmaTagConflictError(`A Fundus asset "${tag}" already exists and is not imported from this tag in file "${fileKey}" — \`fundus asset ingest --figma-tag ${tag}\` would collide; choose another tag.`, existingTags);
+    const existing = Object.hasOwn(library.assets, tag) ? library.assets[tag] : null;
+    if (existing && tagImportedAsset(library, fileKey, tag) === null) {
+        // A replace without --scale falls back to the config default and resets a
+        // slice's pixelRatio to it, so keep the scale a Figma asset was imported at.
+        const savedScale = existing.importSource?.importer === 'figma'
+            ? ` --scale ${validateFigmaSourceParameters(existing.importSource.parameters).scale}`
+            : '';
+        const replace = `\`fundus asset replace ${tag} --from figma --figma-tag ${tag} --figma-file ${fileKey}${savedScale}\``;
+        if (isNodeImportOf(existing, fileKey, nodeId)) {
+            warnings.push(`Fundus asset "${tag}" is imported from this node by id — afterwards run ${replace} to move it to the tag (id, parameters, folder, and manifests stay).`);
+        }
+        else if (!force) {
+            throw new FigmaTagConflictError(`A Fundus asset "${tag}" already exists and is imported neither from this tag nor from this node in file "${fileKey}" — choose another tag, or pass --force to tag the node anyway and then run ${replace}, which replaces the asset's current source.`, existingTags);
+        }
+        else {
+            warnings.push(`Fundus asset "${tag}" already exists from another source — afterwards run ${replace} to switch it to this tag; that replaces its current source.`);
+        }
     }
     const node = nodes.find((candidate) => candidate.nodeId === nodeId) ?? null;
     if (!node) {
@@ -83,7 +109,7 @@ export function planSetFigmaTag(request, { library, document }) {
         }
         warnings.push(`Replaces tag "${previousTag}" on node ${nodeId}.${followUp}`);
     }
-    if (tagImportedAsset(library, fileKey, tag) !== null && !nodes.some((n) => n.tag === tag)) {
+    if (tagImportedAsset(library, fileKey, tag) !== null && previousTag !== tag) {
         warnings.push(`Fundus asset "${tag}" is imported from this tag; its next \`fundus asset reimport ${tag}\` resolves to this node.`);
     }
     return {

package/dist/server/plugins/contract.d.ts

@@ -15,6 +15,9 @@ export interface ProxyOutputInfo {
     height?: number;
     /** Media duration; present for video and audio proxies. */
     durationMs?: number;
+    /** Raw source pixel dimensions; present for slice proxies (pre-compression layout size). */
+    rawWidth?: number;
+    rawHeight?: number;
 }
 /** One delivered asset's current proxy: file identity plus output metadata. */
 export interface AssetProxyInfo extends ProxyOutputInfo {
@@ -101,7 +104,7 @@ export interface ServerAssetTypePlugin<TParameters = unknown, TPreset = unknown>
     /** Run the processing job (sharp/ffmpeg): write the proxy, report its metadata. */
     process(job: ServerProcessingJob<TParameters, TPreset>): Promise<ProxyOutputInfo>;
     /** Probe an existing proxy file's output metadata (the up-to-date path). */
-    readProxyInfo(proxyPath: string, config: ResolvedFundusConfig): Promise<ProxyOutputInfo>;
+    readProxyInfo(proxyPath: string, config: ResolvedFundusConfig, rawPath: string): Promise<ProxyOutputInfo>;
     /**
      * Build the generated manifest entry. Reference fields stay
      * `{ $asset }` markers — codegen's generic inline walk resolves them.
@@ -113,4 +116,4 @@ export type ServerPluginRegistry = Record<string, ServerAssetTypePlugin>;
 /** Resolve a named preset out of a plugin's merged preset map, or throw listing the known names. */
 export declare function resolveNamedPreset<TPreset>(label: string, presetName: string, presets: Record<string, TPreset>): TPreset;
 /** A proxy-info field a given entry kind cannot do without. */
-export declare function requireProxyField(proxy: AssetProxyInfo, field: 'width' | 'height' | 'durationMs'): number;
+export declare function requireProxyField(proxy: AssetProxyInfo, field: keyof ProxyOutputInfo): number;

package/dist/server/plugins/slice.js

@@ -4,7 +4,7 @@
  * redundant pixels from the stretchable regions. The slicing data itself is
  * entry-only.
  */
-import { SLICE_BUILT_IN_PRESETS, defaultInsetsForSize, processedSliceInsets, slicePlugin, validateImagePreset } from '../../core/index.js';
+import { SLICE_BUILT_IN_PRESETS, defaultInsetsForSize, sliceEntryGeometry, slicePlugin, validateImagePreset } from '../../core/index.js';
 import { readImageDimensions } from '../processing/image-processing.js';
 import { processSliceImageFile } from '../processing/slice-processing.js';
 import { extensionForImageFormat } from './image.js';
@@ -21,10 +21,10 @@ export const sliceConfigDefinition = {
         })
     })
 };
-function hasAnySide(insets) {
-    if (!insets)
-        return false;
-    return insets.top > 0 || insets.right > 0 || insets.bottom > 0 || insets.left > 0;
+/** Proxy info plus the raw dimensions the entry's pre-compression layout size needs. */
+async function withRawDimensions(output, rawPath) {
+    const [info, raw] = await Promise.all([output, readImageDimensions(rawPath)]);
+    return { ...info, rawWidth: raw.width, rawHeight: raw.height };
 }
 /**
  * Best-effort guess of the asset's export scale from a `@2x` / `@3x` suffix in
@@ -53,7 +53,7 @@ export const sliceServerPlugin = {
             pixelRatio: detectPixelRatio(rawFileName)
         };
     },
-    process: (job) => processSliceImageFile({
+    process: (job) => withRawDimensions(processSliceImageFile({
         sourcePath: job.sourcePath,
         targetPath: job.targetPath,
         preset: job.preset,
@@ -61,29 +61,12 @@ export const sliceServerPlugin = {
         insets: job.parameters.insets,
         overdraw: job.parameters.overdraw,
         compression: job.parameters.compression
-    }),
-    readProxyInfo: (proxyPath) => readImageDimensions(proxyPath),
-    buildManifestEntry: ({ parameters, src, proxy }) => {
-        const sourceWidth = requireProxyField(proxy, 'width');
-        const sourceHeight = requireProxyField(proxy, 'height');
-        const slicing = {
-            mode: parameters.mode,
-            insets: processedSliceInsets({
-                ...parameters,
-                width: sourceWidth,
-                height: sourceHeight
-            }),
-            pixelRatio: parameters.pixelRatio,
-            // An all-zero overdraw is semantically "none" — keep the entry minimal.
-            ...(hasAnySide(parameters.overdraw) ? { overdraw: parameters.overdraw } : {})
-        };
-        return {
-            kind: 'slice',
-            src,
-            byteSize: proxy.fileSize,
-            slicing,
-            sourceWidth,
-            sourceHeight
-        };
-    }
+    }), job.sourcePath),
+    readProxyInfo: (proxyPath, _config, rawPath) => withRawDimensions(readImageDimensions(proxyPath), rawPath),
+    buildManifestEntry: ({ parameters, src, proxy }) => ({
+        kind: 'slice',
+        src,
+        byteSize: proxy.fileSize,
+        ...sliceEntryGeometry(parameters, { width: requireProxyField(proxy, 'width'), height: requireProxyField(proxy, 'height') }, { width: requireProxyField(proxy, 'rawWidth'), height: requireProxyField(proxy, 'rawHeight') })
+    })
 };