fundus 0.24.0 → 0.26.0

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

@@ -0,0 +1,222 @@
+/**
+ * The `fundus figma` command group: prepare Fundus tag writes for Figma. The
+ * REST API cannot write plugin data, so these commands only validate (tag
+ * grammar, uniqueness in the file, library collisions) and print a script the
+ * caller runs with Figma's MCP `use_figma` tool.
+ */
+import { assetIdError } from '../core/index.js';
+import { loadConfig } from './config-loader.js';
+import { FigmaTagConflictError, loadFigmaTagPlanContext, parseFigmaNodeId, planDeleteFigmaTag, planSetFigmaTag } from './figma-tags.js';
+import { resolveFigmaFileKeyFlag } from './cli-commands.js';
+import { CliUsageError, parseArguments, printJsonDocument, requirePositionals } from './cli-io.js';
+export const FIGMA_HELP = `fundus figma — prepare Fundus tag writes in Figma
+
+Usage: fundus figma <subcommand> … [--json]
+
+The Figma REST API cannot write plugin data, so Fundus cannot tag nodes by
+itself. These commands check the request against the file (via REST) and the
+library, then print a script. Run that script unchanged with the Figma MCP
+\`use_figma\` tool on the same file: it re-checks the live document (the set
+script loads every page, which takes a few seconds on large files), writes
+the tag and its Dev Mode annotation exactly like the Fundus Figma plugin, and
+returns the result. It throws without writing when the document changed.
+
+Subcommands:
+  prepare-set-tag       tag a node (--node-id, --tag)
+  prepare-delete-tag    remove a node's tag (--tag or --node-id)
+
+Requires import.figma.token in fundus.config.ts.
+`;
+const PREPARE_SET_TAG_HELP = `fundus figma prepare-set-tag — prepare a use_figma script that tags a node
+
+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.
+
+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
+  --json              print {"ok": true, "fileKey", "nodeId", "tag",
+                      "previousTag", "warnings", "next", "code"}; a refusal
+                      prints {"ok": false, "error": {"message"}, "existingTags"}
+                      when the file's tags help choose another
+  --help              this help
+
+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>\`.
+
+Example:
+  fundus figma prepare-set-tag --file 'https://www.figma.com/design/abc/UI' \\
+    --node-id 12-34 --tag navigationPanel --json
+`;
+const PREPARE_DELETE_TAG_HELP = `fundus figma prepare-delete-tag — prepare a use_figma script that removes a tag
+
+Usage: fundus figma prepare-delete-tag (--tag <tag> | --node-id <id>)
+                                       [--file <key|link>] [--force] [--json]
+
+Removes the tag and its Dev Mode annotation; other annotations stay. Refuses
+unless --force when a Fundus asset is imported from the tag (its reimport
+would fail afterwards).
+
+Flags:
+  --tag <tag>         the tag to remove (must be on exactly one node)
+  --node-id <id>      the node whose tag to remove: 12:34 or 12-34; with --tag,
+                      both must match
+  --file <key|link>   Figma file key or link; default:
+                      import.figma.defaultFileKey from fundus.config.ts
+  --force             delete even when a Fundus asset is imported from the tag
+  --json              print {"ok": true, "fileKey", "nodeId", "tag",
+                      "warnings", "next", "code"}; refusals as for
+                      prepare-set-tag
+  --help              this help
+
+The script returns {"ok": true, "nodeId", "nodeName", "removedTag",
+"annotationRemoved"}.
+
+Example:
+  fundus figma prepare-delete-tag --tag navigationPanel --json
+`;
+const FIGMA_SUBCOMMAND_HELP = {
+    'prepare-set-tag': PREPARE_SET_TAG_HELP,
+    'prepare-delete-tag': PREPARE_DELETE_TAG_HELP
+};
+const TAG_FLAGS = {
+    json: { takesValue: false },
+    help: { takesValue: false },
+    file: { takesValue: true },
+    'node-id': { takesValue: true },
+    tag: { takesValue: true },
+    force: { takesValue: false }
+};
+/** Fail on a malformed tag before any Figma request. */
+function assertTag(tag) {
+    const problem = tag === undefined ? null : assetIdError(tag);
+    if (problem)
+        throw new Error(problem);
+}
+function stringFlag(parsed, name) {
+    const value = parsed.flags[name];
+    return typeof value === 'string' ? value : undefined;
+}
+async function resolvePlanInputs(parsed, commandPath) {
+    const config = await loadConfig(process.cwd());
+    const fileFlag = stringFlag(parsed, 'file');
+    const fileKey = fileFlag !== undefined ? resolveFigmaFileKeyFlag(fileFlag) : config.import.figma.defaultFileKey;
+    if (!fileKey) {
+        throw new CliUsageError(`\`${commandPath}\` needs --file <key|link> or import.figma.defaultFileKey in fundus.config.ts.`);
+    }
+    return { fileKey, context: await loadFigmaTagPlanContext(config, fileKey) };
+}
+function nextStep(fileKey, subject = '"code"') {
+    return `Run ${subject} unchanged with the Figma MCP use_figma tool on fileKey "${fileKey}". It returns the result as JSON, or throws without writing when the live document disagrees.`;
+}
+/** Refusals that list the file's tags get their own document; others take the standard error path. */
+function reportConflict(cause, json) {
+    if (!(cause instanceof FigmaTagConflictError))
+        return false;
+    if (json) {
+        printJsonDocument({
+            ok: false,
+            error: { message: cause.message },
+            existingTags: cause.existingTags
+        });
+    }
+    else {
+        console.error(`fundus: ${cause.message}`);
+        console.error(cause.existingTags.length === 0 ? 'No tags in this file yet.' : 'Existing tags in this file:');
+        for (const entry of cause.existingTags) {
+            console.error(`  ${entry.tag}  ${entry.nodeId}  "${entry.nodeName}" (page "${entry.page}")`);
+        }
+    }
+    process.exitCode = 1;
+    return true;
+}
+function printPlan(plan, document, json) {
+    if (json) {
+        printJsonDocument({ ok: true, ...document, next: nextStep(plan.fileKey), code: plan.code });
+        return;
+    }
+    for (const warning of plan.warnings)
+        console.error(`⚠ ${warning}`);
+    console.error(`${nextStep(plan.fileKey, 'the script below')}\n`);
+    process.stdout.write(plan.code);
+}
+async function runPrepareSetTag(argumentList) {
+    const commandPath = 'fundus figma prepare-set-tag';
+    const parsed = parseArguments(argumentList, TAG_FLAGS, commandPath);
+    requirePositionals(parsed, [], commandPath);
+    const nodeIdFlag = stringFlag(parsed, 'node-id');
+    const tag = stringFlag(parsed, 'tag');
+    if (nodeIdFlag === undefined || tag === undefined) {
+        throw new CliUsageError(`\`${commandPath}\` needs --node-id and --tag — run \`${commandPath} --help\`.`);
+    }
+    const nodeId = parseFigmaNodeId(nodeIdFlag);
+    assertTag(tag);
+    const json = parsed.flags.json === true;
+    const { fileKey, context } = await resolvePlanInputs(parsed, commandPath);
+    try {
+        const plan = planSetFigmaTag({ fileKey, nodeId, tag, force: parsed.flags.force === true }, context);
+        printPlan(plan, {
+            fileKey,
+            nodeId: plan.nodeId,
+            tag: plan.tag,
+            previousTag: plan.previousTag,
+            warnings: plan.warnings
+        }, json);
+    }
+    catch (cause) {
+        if (!reportConflict(cause, json))
+            throw cause;
+    }
+}
+async function runPrepareDeleteTag(argumentList) {
+    const commandPath = 'fundus figma prepare-delete-tag';
+    const parsed = parseArguments(argumentList, TAG_FLAGS, commandPath);
+    requirePositionals(parsed, [], commandPath);
+    const nodeIdFlag = stringFlag(parsed, 'node-id');
+    const tag = stringFlag(parsed, 'tag');
+    if (nodeIdFlag === undefined && tag === undefined) {
+        throw new CliUsageError(`\`${commandPath}\` needs --tag or --node-id — run \`${commandPath} --help\`.`);
+    }
+    const nodeId = nodeIdFlag === undefined ? undefined : parseFigmaNodeId(nodeIdFlag);
+    assertTag(tag);
+    const json = parsed.flags.json === true;
+    const { fileKey, context } = await resolvePlanInputs(parsed, commandPath);
+    try {
+        const plan = planDeleteFigmaTag({ fileKey, nodeId, tag, force: parsed.flags.force === true }, context);
+        printPlan(plan, { fileKey, nodeId: plan.nodeId, tag: plan.tag, warnings: plan.warnings }, json);
+    }
+    catch (cause) {
+        if (!reportConflict(cause, json))
+            throw cause;
+    }
+}
+export async function runFigmaCommand(argumentList) {
+    const [subcommand, ...rest] = argumentList;
+    if (subcommand === undefined || subcommand === '--help') {
+        console.log(FIGMA_HELP);
+        if (subcommand === undefined) {
+            throw new CliUsageError('`fundus figma` needs a subcommand: prepare-set-tag, prepare-delete-tag.');
+        }
+        return;
+    }
+    if (rest.includes('--help')) {
+        console.log(FIGMA_SUBCOMMAND_HELP[subcommand] ?? FIGMA_HELP);
+        return;
+    }
+    switch (subcommand) {
+        case 'prepare-set-tag':
+            return runPrepareSetTag(rest);
+        case 'prepare-delete-tag':
+            return runPrepareDeleteTag(rest);
+        default:
+            throw new CliUsageError(`Unknown subcommand "figma ${subcommand}" — run \`fundus figma --help\`.`);
+    }
+}

package/dist/server/figma-tags.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Planning for the `fundus figma prepare-*-tag` commands. The Figma REST API
+ * can read shared plugin data but not write it, so Fundus validates against a
+ * REST snapshot of the file plus the local library, then hands back a
+ * `use_figma` script (figma-tag-script.ts) that performs the write inside
+ * Figma and re-checks the live document first.
+ */
+import { type Library } from '../core/index.js';
+import type { ResolvedFundusConfig } from './config-loader.js';
+/** A tagged node in the file, as reported alongside conflicts. */
+export interface FigmaTagListing {
+    tag: string;
+    nodeId: string;
+    nodeName: string;
+    page: string;
+}
+/** An expected refusal that carries the file's current tags so the caller can pick another. */
+export declare class FigmaTagConflictError extends Error {
+    readonly existingTags: FigmaTagListing[];
+    constructor(message: string, existingTags: FigmaTagListing[]);
+}
+export interface FigmaTagPlan {
+    fileKey: string;
+    nodeId: string;
+    /** Non-fatal findings the caller should relay (e.g. a Fundus asset to reimport). */
+    warnings: string[];
+    /** The `use_figma` script body. */
+    code: string;
+}
+export interface SetFigmaTagPlan extends FigmaTagPlan {
+    tag: string;
+    /** The node's tag per the REST snapshot; null when untagged or not yet visible. */
+    previousTag: string | null;
+}
+export interface DeleteFigmaTagPlan extends FigmaTagPlan {
+    tag: string;
+}
+/** Normalize a `12:34` / `12-34` node id; Fundus imports only this id form. */
+export declare function parseFigmaNodeId(value: string): string;
+export interface FigmaTagPlanContext {
+    library: Library;
+    /** REST document tree of the file, with shared plugin data. */
+    document: unknown;
+}
+export interface SetFigmaTagRequest {
+    fileKey: string;
+    nodeId: string;
+    tag: string;
+    force: boolean;
+}
+export declare function planSetFigmaTag(request: SetFigmaTagRequest, { library, document }: FigmaTagPlanContext): SetFigmaTagPlan;
+export interface DeleteFigmaTagRequest {
+    fileKey: string;
+    /** Exactly one of nodeId / tag identifies the node; both must agree when given. */
+    nodeId?: string;
+    tag?: string;
+    force: boolean;
+}
+export declare function planDeleteFigmaTag(request: DeleteFigmaTagRequest, { library, document }: FigmaTagPlanContext): DeleteFigmaTagPlan;
+/** Load the library and the file's REST document for planning. */
+export declare function loadFigmaTagPlanContext(config: ResolvedFundusConfig, fileKey: string): Promise<FigmaTagPlanContext>;

package/dist/server/figma-tags.js

@@ -0,0 +1,153 @@
+/**
+ * Planning for the `fundus figma prepare-*-tag` commands. The Figma REST API
+ * can read shared plugin data but not write it, so Fundus validates against a
+ * REST snapshot of the file plus the local library, then hands back a
+ * `use_figma` script (figma-tag-script.ts) that performs the write inside
+ * Figma and re-checks the live document first.
+ */
+import { assetIdError, buildDeleteTagScript, buildSetTagScript } from '../core/index.js';
+import { fetchFigmaDocument, figmaDocumentNodes, validateFigmaSourceParameters } from './importers/figma.js';
+import { LibraryStore } from './library-store.js';
+/** An expected refusal that carries the file's current tags so the caller can pick another. */
+export class FigmaTagConflictError extends Error {
+    existingTags;
+    constructor(message, existingTags) {
+        super(message);
+        this.existingTags = existingTags;
+    }
+}
+/** Normalize a `12:34` / `12-34` node id; Fundus imports only this id form. */
+export function parseFigmaNodeId(value) {
+    if (!/^\d+[-:]\d+$/.test(value)) {
+        throw new Error(`"${value}" is not a taggable Figma node id — use the form 12:34 (or 12-34 as in a node-id link parameter). Nodes inside instances (ids starting with "I") inherit their tag from the main component; tag the node there.`);
+    }
+    return value.replace('-', ':');
+}
+function tagListing(nodes) {
+    return nodes
+        .filter((node) => node.tag !== null)
+        .map((node) => ({
+        tag: node.tag,
+        nodeId: node.nodeId,
+        nodeName: node.nodeName,
+        page: node.page
+    }))
+        .sort((a, b) => a.tag.localeCompare(b.tag));
+}
+function describeNode(node) {
+    return `"${node.nodeName}" (${node.nodeId}) on page "${node.page}"`;
+}
+/** The library asset imported from `tag` in `fileKey`, if any. */
+function tagImportedAsset(library, fileKey, tag) {
+    const record = library.assets[tag];
+    if (record?.importSource?.importer !== 'figma')
+        return null;
+    const source = validateFigmaSourceParameters(record.importSource.parameters);
+    return source.mode === 'tag' && source.fundusTag === tag && source.fileKey === fileKey
+        ? tag
+        : null;
+}
+export function planSetFigmaTag(request, { library, document }) {
+    const { fileKey, nodeId, tag, force } = request;
+    const problem = assetIdError(tag);
+    if (problem)
+        throw new Error(problem);
+    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);
+    }
+    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 node = nodes.find((candidate) => candidate.nodeId === nodeId) ?? null;
+    if (!node) {
+        warnings.push(`Node ${nodeId} is not in the Figma REST snapshot yet (new or unsynced node); the script verifies it exists before writing.`);
+    }
+    const previousTag = node?.tag ?? null;
+    if (previousTag === tag) {
+        if (!force) {
+            throw new Error(`Node ${describeNode(node)} already carries tag "${tag}" — nothing to do. Pass --force to regenerate the script anyway (e.g. to repair its annotation).`);
+        }
+        warnings.push(`Node ${nodeId} already carries tag "${tag}"; the script rewrites it.`);
+    }
+    else if (previousTag !== null) {
+        const orphaned = tagImportedAsset(library, fileKey, previousTag);
+        const followUp = orphaned
+            ? ` Fundus asset "${orphaned}" is imported from that tag — afterwards run \`fundus asset reimport ${orphaned} --figma-tag ${tag}\` (renames it to "${tag}").`
+            : '';
+        if (!force) {
+            throw new Error(`Node ${describeNode(node)} already carries tag "${previousTag}". Pass --force to replace it.${followUp}`);
+        }
+        warnings.push(`Replaces tag "${previousTag}" on node ${nodeId}.${followUp}`);
+    }
+    if (tagImportedAsset(library, fileKey, tag) !== null && !nodes.some((n) => n.tag === tag)) {
+        warnings.push(`Fundus asset "${tag}" is imported from this tag; its next \`fundus asset reimport ${tag}\` resolves to this node.`);
+    }
+    return {
+        fileKey,
+        nodeId,
+        tag,
+        previousTag,
+        warnings,
+        code: buildSetTagScript({ nodeId, tag, force })
+    };
+}
+export function planDeleteFigmaTag(request, { library, document }) {
+    const { fileKey, force } = request;
+    if (request.tag !== undefined) {
+        const problem = assetIdError(request.tag);
+        if (problem)
+            throw new Error(problem);
+    }
+    const nodes = figmaDocumentNodes(document);
+    const existingTags = tagListing(nodes);
+    let node;
+    if (request.nodeId !== undefined) {
+        const found = nodes.find((candidate) => candidate.nodeId === request.nodeId);
+        if (!found) {
+            throw new Error(`Node ${request.nodeId} is not in Figma file "${fileKey}".`);
+        }
+        if (found.tag === null) {
+            throw new FigmaTagConflictError(`Node ${describeNode(found)} carries no Fundus tag (existing tags are listed).`, existingTags);
+        }
+        if (request.tag !== undefined && found.tag !== request.tag) {
+            throw new FigmaTagConflictError(`Node ${describeNode(found)} carries tag "${found.tag}", not "${request.tag}".`, existingTags);
+        }
+        node = found;
+    }
+    else {
+        const matches = nodes.filter((candidate) => candidate.tag === request.tag);
+        if (matches.length === 0) {
+            throw new FigmaTagConflictError(`No node carries tag "${request.tag}" in Figma file "${fileKey}" (existing tags are listed).`, existingTags);
+        }
+        if (matches.length > 1) {
+            throw new FigmaTagConflictError(`Tag "${request.tag}" is on ${matches.length} nodes (${matches.map((match) => match.nodeId).join(', ')}) — pass --node-id to pick one.`, existingTags);
+        }
+        node = matches[0];
+    }
+    const tag = node.tag;
+    const warnings = [];
+    const imported = tagImportedAsset(library, fileKey, tag);
+    if (imported) {
+        const consequence = `Fundus asset "${imported}" is imported from this tag; without it, \`fundus asset reimport ${imported}\` fails until the tag is set again.`;
+        if (!force)
+            throw new Error(`${consequence} Pass --force to delete the tag anyway.`);
+        warnings.push(consequence);
+    }
+    return {
+        fileKey,
+        nodeId: node.nodeId,
+        tag,
+        warnings,
+        code: buildDeleteTagScript({ nodeId: node.nodeId, tag })
+    };
+}
+/** Load the library and the file's REST document for planning. */
+export async function loadFigmaTagPlanContext(config, fileKey) {
+    const library = await new LibraryStore(config).read();
+    const document = await fetchFigmaDocument(fileKey, { config, fetch: globalThis.fetch });
+    return { library, document };
+}

package/dist/server/importers/figma.d.ts

@@ -40,5 +40,22 @@ export declare function parseFigmaFileKey(value: string): string;
 export declare function validateFigmaSourceParameters(value: unknown): FigmaSourceParameters;
 export declare function resolveSafeDownloadTarget(value: string | URL): Promise<PinnedHttpsTarget>;
 export declare function assertSafeDownloadUrl(value: string | URL): Promise<URL>;
+/** One node in a Figma REST document tree, as the tag commands report it. */
+export interface FigmaDocumentNode {
+    nodeId: string;
+    nodeName: string;
+    /** Name of the page (canvas) containing the node. */
+    page: string;
+    /** The node's Fundus tag, or null when untagged. */
+    tag: string | null;
+}
+/**
+ * Every taggable node in a REST document tree (`plugin_data=shared`), in
+ * document order. Nodes inside instances are skipped: they echo the main
+ * component node's tag, and Fundus imports only plain `12:34` node ids.
+ */
+export declare function figmaDocumentNodes(document: unknown): FigmaDocumentNode[];
+/** The whole document tree of a Figma file, including every node's shared plugin data. */
+export declare function fetchFigmaDocument(fileKey: string, context: ImporterContext): Promise<unknown>;
 export declare function resolveTagToNode(fileKey: string, tag: string, context: ImporterContext): Promise<string>;
 export declare const figmaSourceImporter: ServerSourceImporter<FigmaImportInput, FigmaSourceParameters>;

package/dist/server/importers/figma.js

@@ -1,7 +1,7 @@
 import { lookup } from 'node:dns/promises';
 import { isIP } from 'node:net';
 import sharp from 'sharp';
-import { isValidAssetId } from '../../core/index.js';
+import { isInstanceSublayerId, isValidAssetId } from '../../core/index.js';
 import { SourceImportError, invalidInput } from './contract.js';
 import { requestPinnedHttps } from './pinned-https.js';
 const MAX_DOWNLOAD_BYTES = 50 * 1024 * 1024;
@@ -383,21 +383,43 @@ async function validatePng(bytes) {
         throw new SourceImportError('image-too-large', 'Figma export exceeds the 32 megapixel limit.');
     }
 }
-function collectTaggedNodeIds(node, tag, matches) {
-    const current = record(node);
-    if (!current)
-        return;
-    const shared = record(current.sharedPluginData);
-    const fundus = shared ? record(shared.fundus) : null;
-    if (fundus && fundus.assetId === tag && typeof current.id === 'string') {
-        matches.push(current.id);
-    }
-    if (Array.isArray(current.children)) {
-        for (const child of current.children)
-            collectTaggedNodeIds(child, tag, matches);
-    }
+/**
+ * Every taggable node in a REST document tree (`plugin_data=shared`), in
+ * document order. Nodes inside instances are skipped: they echo the main
+ * component node's tag, and Fundus imports only plain `12:34` node ids.
+ */
+export function figmaDocumentNodes(document) {
+    const nodes = [];
+    const visit = (value, page) => {
+        const current = record(value);
+        if (!current)
+            return;
+        const name = typeof current.name === 'string' ? current.name : '';
+        const pageName = current.type === 'CANVAS' ? name : page;
+        if (typeof current.id === 'string' &&
+            current.type !== 'DOCUMENT' &&
+            current.type !== 'CANVAS' &&
+            !isInstanceSublayerId(current.id)) {
+            const shared = record(current.sharedPluginData);
+            const fundus = shared ? record(shared.fundus) : null;
+            const tag = fundus && typeof fundus.assetId === 'string' ? fundus.assetId : '';
+            nodes.push({
+                nodeId: current.id,
+                nodeName: name,
+                page: pageName,
+                tag: tag === '' ? null : tag
+            });
+        }
+        if (Array.isArray(current.children)) {
+            for (const child of current.children)
+                visit(child, pageName);
+        }
+    };
+    visit(record(document), '');
+    return nodes;
 }
-export async function resolveTagToNode(fileKey, tag, context) {
+/** The whole document tree of a Figma file, including every node's shared plugin data. */
+export async function fetchFigmaDocument(fileKey, context) {
     const token = context.config.import.figma.token;
     if (!token) {
         throw new SourceImportError('not-configured', 'Figma access is not configured.');
@@ -416,15 +438,18 @@ export async function resolveTagToNode(fileKey, tag, context) {
     if (!body || body.err || (typeof body.status === 'number' && body.status >= 400)) {
         throw new SourceImportError('invalid-response', 'Figma returned an invalid response.');
     }
-    const matches = [];
-    collectTaggedNodeIds(body.document, tag, matches);
+    return body.document;
+}
+export async function resolveTagToNode(fileKey, tag, context) {
+    const document = await fetchFigmaDocument(fileKey, context);
+    const matches = figmaDocumentNodes(document).filter((node) => node.tag === tag);
     if (matches.length === 0) {
         throw new SourceImportError('not-found', `No Figma node is tagged "${tag}" in this file.`);
     }
     if (matches.length > 1) {
         throw new SourceImportError('ambiguous-tag', `More than one Figma node is tagged "${tag}" in this file.`);
     }
-    return matches[0];
+    return matches[0].nodeId;
 }
 async function materialize(source, context) {
     const token = context.config.import.figma.token;

package/package.json

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

package/build/client/_app/immutable/entry/start.CTftTL5f.js

@@ -1 +0,0 @@
-import{c as e,r as t}from"../chunks/CCIxsMRK.js";export{e as load_css,t as start};

package/build/client/_app/immutable/nodes/1.xSi5hUiK.js.br

@@ -1 +0,0 @@
-w
`�ۦ�M�uEE