@cardanvil/frame-kit 0.4.0 → 0.6.0

package/dist/cli/studio/session.d.ts

@@ -0,0 +1,73 @@
+import type { Frame } from "../../schema/frame.js";
+import { type DiscoveredFrame } from "../discover.js";
+import { type FrameServer } from "../loadFrame.js";
+import { type Problem } from "../report.js";
+import { type LayoutSlot } from "./boxSets.js";
+import { type SourceIndex } from "./edit/sourceIndex.js";
+import { type TypeScriptApi } from "./edit/ts.js";
+/** One box / asset / mask set present in a frame, addressed by logical path. */
+export interface FrameSlot extends LayoutSlot {
+    /** `null` for `config.layouts`, else the `alternateLayouts` key. */
+    readonly variant: string | null;
+    readonly layout: string;
+    readonly path: readonly string[];
+    /** Which `CardBoxes` members this set actually defines. */
+    readonly boxKeys?: readonly string[];
+}
+export interface FramePayload {
+    readonly slug: string;
+    readonly id: string;
+    readonly name: string;
+    /** Bumps on every successful reload, so the client can drop stale state. */
+    readonly revision: number;
+    readonly canvas: {
+        readonly width: number;
+        readonly height: number;
+    };
+    /** The validated frame, with asset URLs rewritten to studio endpoints. */
+    readonly frame: unknown;
+    readonly slots: readonly FrameSlot[];
+    /** Root-relative POSIX paths of every source file the frame was built from. */
+    readonly sourceFiles: readonly string[];
+    readonly problems: readonly Problem[];
+    /** True when this is the last good load and the newest one failed. */
+    readonly stale: boolean;
+    readonly staleProblems?: readonly Problem[];
+}
+export interface FrameSummary {
+    readonly slug: string;
+    readonly id: string;
+    readonly name: string;
+    readonly stale: boolean;
+}
+interface Entry {
+    payload: FramePayload;
+    /** The frame before URL rewriting — what edits are verified against. */
+    raw: Frame;
+    discovered: DiscoveredFrame;
+}
+export interface StudioSession {
+    readonly root: string;
+    readonly index: SourceIndex;
+    readonly api: TypeScriptApi;
+    readonly frameServer: FrameServer;
+    list: () => FrameSummary[];
+    get: (slug: string) => Entry | undefined;
+    /** Absolute source files worth watching, across every loaded frame. */
+    watchDirs: () => string[];
+    reload: (only?: readonly string[]) => Promise<string[]>;
+    close: () => Promise<void>;
+}
+/**
+ * Owns the Vite server, the loaded frames, and the last-good cache.
+ *
+ * A frame that fails to load keeps its previous payload — an author mid-save
+ * produces a syntax error on almost every keystroke, and blanking the canvas
+ * each time would make the studio unusable. `loadFrames` already routes every
+ * failure into the reporter instead of throwing, so a failed pass simply
+ * yields no frame for that slug.
+ */
+export declare function startSession(root: string, only?: readonly string[]): Promise<StudioSession>;
+/** Frames discoverable under `root`, for a startup message. */
+export declare function countFrames(root: string): Promise<number>;
+export {};

package/dist/cli/studio/session.js

@@ -0,0 +1,154 @@
+import path from "node:path";
+import { walkAssets } from "../../manifest/walk.js";
+import { setAtPath } from "../../manifest/walk.js";
+import { DEFAULT_CANVAS_HEIGHT, DEFAULT_CANVAS_WIDTH, } from "../../schema/frame.js";
+import { FrameSchema } from "../../schema/frame.js";
+import { loadFrames } from "../api.js";
+import { discoverFrames, relativePosix, } from "../discover.js";
+import { invalidateFrameModules, startFrameServer, } from "../loadFrame.js";
+import { Reporter } from "../report.js";
+import { layoutSlots } from "./boxSets.js";
+import { createSourceIndex } from "./edit/sourceIndex.js";
+import { isUnderRoot, normalizeFile, } from "./edit/sourceIndex.js";
+import { loadTypeScript } from "./edit/ts.js";
+/** Every box/asset/mask set a loaded frame actually defines. */
+function slotsFor(frame) {
+    const slots = layoutSlots();
+    const found = [];
+    const collect = (container, variant, prefix) => {
+        for (const [layout, config] of Object.entries(container ?? {})) {
+            if (!config || typeof config !== "object") {
+                continue;
+            }
+            const record = config;
+            for (const slot of slots) {
+                const value = record[slot.key];
+                if (!value || typeof value !== "object") {
+                    continue;
+                }
+                found.push({
+                    ...slot,
+                    variant,
+                    layout,
+                    path: [...prefix, layout, slot.key],
+                    ...(slot.kind === "boxes" ? { boxKeys: Object.keys(value) } : {}),
+                });
+            }
+        }
+    };
+    const config = frame.config;
+    collect(config.layouts, null, ["config", "layouts"]);
+    for (const [variant, layouts] of Object.entries(config.alternateLayouts ?? {})) {
+        collect(layouts, variant, ["config", "alternateLayouts", variant]);
+    }
+    return found;
+}
+/**
+ * Rewrites every asset URL to the studio's own endpoint.
+ *
+ * Driven by `walkAssets` rather than a field list, so an asset field added to
+ * the contract is served without touching this.
+ */
+function rewriteAssets(frame) {
+    const plain = JSON.parse(JSON.stringify(frame));
+    for (const occurrence of walkAssets(FrameSchema, plain)) {
+        setAtPath(plain, occurrence.path, `/api/asset?u=${encodeURIComponent(occurrence.url)}`);
+    }
+    return plain;
+}
+/**
+ * Owns the Vite server, the loaded frames, and the last-good cache.
+ *
+ * A frame that fails to load keeps its previous payload — an author mid-save
+ * produces a syntax error on almost every keystroke, and blanking the canvas
+ * each time would make the studio unusable. `loadFrames` already routes every
+ * failure into the reporter instead of throwing, so a failed pass simply
+ * yields no frame for that slug.
+ */
+export async function startSession(root, only = []) {
+    const resolvedRoot = path.resolve(root);
+    const frameServer = await startFrameServer(resolvedRoot);
+    const api = await loadTypeScript();
+    const index = createSourceIndex(api);
+    const cache = new Map();
+    let revision = 0;
+    async function reload(slugs) {
+        invalidateFrameModules(frameServer);
+        const reporter = new Reporter();
+        const wanted = slugs ?? only;
+        const loaded = await loadFrames({ root: resolvedRoot, ...(wanted.length > 0 ? { only: wanted } : {}) }, reporter, frameServer);
+        const seen = new Set();
+        const sourceFiles = [
+            ...frameServer.server.environments.ssr.moduleGraph.fileToModulesMap.keys(),
+        ]
+            .filter((file) => isUnderRoot(file, resolvedRoot) && /\.[cm]?tsx?$/.test(file))
+            .map((file) => relativePosix(resolvedRoot, file))
+            .sort();
+        for (const item of loaded) {
+            const { discovered, frame } = item;
+            seen.add(discovered.slug);
+            revision += 1;
+            const canvas = frame.config.canvas ?? {
+                width: DEFAULT_CANVAS_WIDTH,
+                height: DEFAULT_CANVAS_HEIGHT,
+            };
+            cache.set(discovered.slug, {
+                raw: frame,
+                discovered,
+                payload: {
+                    slug: discovered.slug,
+                    id: discovered.meta.id,
+                    name: frame.name,
+                    revision,
+                    canvas,
+                    frame: rewriteAssets(frame),
+                    slots: slotsFor(frame),
+                    sourceFiles,
+                    problems: reporter.problems.filter((problem) => problem.frame === discovered.slug),
+                    stale: false,
+                },
+            });
+        }
+        // Anything asked for that did not come back kept its last good payload.
+        for (const [slug, entry] of cache) {
+            if (seen.has(slug) || (wanted.length > 0 && !wanted.includes(slug))) {
+                continue;
+            }
+            const problems = reporter.problems.filter((problem) => problem.frame === slug || problem.frame === undefined);
+            cache.set(slug, {
+                ...entry,
+                payload: { ...entry.payload, stale: true, staleProblems: problems },
+            });
+        }
+        return [...seen];
+    }
+    await reload();
+    return {
+        root: resolvedRoot,
+        index,
+        api,
+        frameServer,
+        list: () => [...cache.values()]
+            .map((entry) => ({
+            slug: entry.payload.slug,
+            id: entry.payload.id,
+            name: entry.payload.name,
+            stale: entry.payload.stale,
+        }))
+            .sort((a, b) => a.slug.localeCompare(b.slug)),
+        get: (slug) => cache.get(slug),
+        watchDirs: () => {
+            const dirs = new Set([resolvedRoot]);
+            for (const entry of cache.values()) {
+                dirs.add(normalizeFile(entry.discovered.dir));
+            }
+            return [...dirs];
+        },
+        reload,
+        close: () => frameServer.close(),
+    };
+}
+/** Frames discoverable under `root`, for a startup message. */
+export async function countFrames(root) {
+    return (await discoverFrames(path.resolve(root), new Reporter())).length;
+}

package/dist/cli/watch.d.ts

@@ -9,6 +9,9 @@ export interface WatchOptions extends BuildOptions {
  * One Vite server stays alive for the whole session — starting one costs a
  * second or two — and its module graph is dropped before each rebuild so an
  * edit is actually seen. See `invalidateFrameModules`.
+ *
+ * Debouncing, ignore rules and the non-overlapping drain live in
+ * `startSourceWatcher`, shared with `frame-kit studio`.
  */
 export declare function watchFrames(options: WatchOptions): Promise<void>;
 /**

package/dist/cli/watch.js

@@ -1,30 +1,9 @@
-import { watch } from "node:fs";
 import path from "node:path";
 import { buildFrames } from "./build.js";
-import { discoverFrames, relativePosix } from "./discover.js";
+import { discoverFrames } from "./discover.js";
 import { invalidateFrameModules, startFrameServer } from "./loadFrame.js";
 import { Reporter, formatProblem } from "./report.js";
-/** Directories never worth watching. Mirrors discovery's own skip list. */
-const SKIP_DIRS = new Set([
-    "node_modules",
-    "dist",
-    ".git",
-    ".pnpm-store",
-    "__fixtures__",
-]);
-/** Files a rebuild produces, or an editor leaves lying around. */
-const IGNORED_FILE = /(\.cardframe|frame-index\.json|\.preview\.[a-z]+|~|\.swp|\.tmp)$/i;
-/**
- * How long to wait for changes to stop before rebuilding.
- *
- * One save can produce several events — a write, a rename, an attribute
- * change — and a tool upstream may rewrite a whole directory.
- */
-const DEBOUNCE_MS = 200;
-function isIgnored(file) {
-    const segments = file.split(path.sep);
-    return (segments.some((segment) => SKIP_DIRS.has(segment) || segment.startsWith(".")) || IGNORED_FILE.test(file));
-}
+import { startSourceWatcher } from "./sourceWatcher.js";
 const plural = (n) => `${String(n)} frame${n === 1 ? "" : "s"}`;
 /**
  * Rebuilds frames as their sources change, until the process is interrupted.
@@ -32,6 +11,9 @@ const plural = (n) => `${String(n)} frame${n === 1 ? "" : "s"}`;
  * One Vite server stays alive for the whole session — starting one costs a
  * second or two — and its module graph is dropped before each rebuild so an
  * edit is actually seen. See `invalidateFrameModules`.
+ *
+ * Debouncing, ignore rules and the non-overlapping drain live in
+ * `startSourceWatcher`, shared with `frame-kit studio`.
  */
 export async function watchFrames(options) {
     const root = path.resolve(options.root);
@@ -41,10 +23,7 @@ export async function watchFrames(options) {
             console.log(summary);
         });
     const frameServer = await startFrameServer(root);
-    const watchers = [];
-    const pending = new Set();
-    let timer;
-    let building = false;
+    let watcher;
     function runBuild(only) {
         invalidateFrameModules(frameServer);
         const reporter = new Reporter();
@@ -56,66 +35,23 @@ export async function watchFrames(options) {
             report(`${plural(frames.length)} rebuilt in ${String(Date.now() - started)}ms`);
         });
     }
-    async function drain() {
-        if (building) {
-            // Two builds would race on the same output file. Whatever arrived is
-            // already in `pending`, and the loop below will pick it up.
-            return;
-        }
-        building = true;
-        try {
-            // Keyed off `pending` rather than a flag: anything that arrived during a
-            // build is still queued when it finishes.
-            while (pending.size > 0) {
-                const changed = [...pending];
-                pending.clear();
-                const slugs = await slugsFor(root, changed, options.only);
-                if (slugs?.length === 0) {
-                    continue; // nothing we build was touched
-                }
-                await runBuild(slugs);
-            }
-        }
-        catch (cause) {
-            // A failed rebuild must not end the session: the author is mid-edit and
-            // the next save is probably the fix.
-            console.error(cause instanceof Error ? cause.message : String(cause));
-        }
-        finally {
-            building = false;
-        }
-    }
-    function onChange(file) {
-        if (isIgnored(file) || file.startsWith(outDir)) {
-            return;
-        }
-        pending.add(file);
-        if (timer) {
-            clearTimeout(timer);
-        }
-        timer = setTimeout(() => void drain(), DEBOUNCE_MS);
-    }
-    function watchDir(dir) {
-        try {
-            watchers.push(watch(dir, { recursive: true }, (_event, name) => {
-                if (name !== null) {
-                    onChange(path.join(dir, name));
-                }
-            }));
-        }
-        catch {
-            console.error(`Could not watch ${relativePosix(root, dir)}. Recursive watching is ` +
-                `not supported on this filesystem; rebuild with \`frame-kit build\`.`);
-        }
-    }
     try {
         await runBuild(undefined);
         // Each frame's own directory, plus the root, so a frame added or removed
         // while watching is noticed.
-        for (const frame of await discoverFrames(root, new Reporter())) {
-            watchDir(frame.dir);
-        }
-        watchDir(root);
+        const frames = await discoverFrames(root, new Reporter());
+        watcher = startSourceWatcher({
+            root,
+            dirs: [...frames.map((frame) => frame.dir), root],
+            ignore: (file) => file.startsWith(outDir),
+            onChange: async (changed) => {
+                const slugs = await slugsFor(root, changed, options.only);
+                if (slugs?.length === 0) {
+                    return; // nothing we build was touched
+                }
+                await runBuild(slugs);
+            },
+        });
         report("Watching for changes. Press Ctrl+C to stop.");
         await new Promise((resolve) => {
             const stop = () => {
@@ -126,12 +62,7 @@ export async function watchFrames(options) {
         });
     }
     finally {
-        if (timer) {
-            clearTimeout(timer);
-        }
-        for (const watcher of watchers) {
-            watcher.close();
-        }
+        watcher?.close();
         await frameServer.close();
     }
 }

package/dist/layout/assetPlacement.d.ts

@@ -0,0 +1,71 @@
+import type { CrownRenderConfig, NicknameRenderConfig } from "../schema/frame.js";
+/** Where the PT plate sits when a layout does not say. */
+export declare const DEFAULT_PT_IMAGE: {
+    readonly x: 2441;
+    readonly y: 3847;
+};
+/** The crown's black bar is fixed art at a fixed place. */
+export declare const CROWN_BLACK_BAR: {
+    readonly x: 220;
+    readonly y: 200;
+    readonly width: 2815;
+    readonly height: 140;
+};
+/** Horizontal fallback for the nyx insert when the crown's width is unknown. */
+export declare const NYX_INSERT_FALLBACK_X = 611;
+export interface PlacementConfig {
+    readonly crownConfig?: CrownRenderConfig | undefined;
+    readonly nicknameConfig?: NicknameRenderConfig | undefined;
+    readonly ptImage?: {
+        readonly x: number;
+        readonly y: number;
+    } | undefined;
+    /** Whether the card being previewed has a nickname; moves the crown. */
+    readonly hasNickname?: boolean;
+}
+export interface Placed {
+    readonly x: number;
+    readonly y: number;
+}
+export type Placement = 
+/** Centred on the canvas — full-sheet art. */
+{
+    readonly kind: "center";
+}
+/** Drawn at a fixed point on the sheet. */
+ | {
+    readonly kind: "at";
+    readonly at: Placed;
+}
+/**
+ * Positioned by the renderer at draw time from measurements nothing static
+ * has — ability rows, saga chapters, the flipside plate.
+ */
+ | {
+    readonly kind: "dynamic";
+    readonly reason: string;
+};
+/**
+ * Where an asset is drawn on the sheet.
+ *
+ * Most frame art is full-sheet and simply centres, but several families do
+ * not: crowns, nicknames and the PT plate are placed from the layout's own
+ * render config, and drawing them centred — as a naive compositor does — puts
+ * a legendary crown in the middle of the card. The positions here mirror
+ * Card Anvil's `konva/nodes/imageNodes.ts`, which is the authority.
+ *
+ * `assetPath` is the dotted path within a `FrameAssets`, as `walkAssets`
+ * reports it: `base.w`, `crown.nickname`, `pt.u`, and so on.
+ */
+export declare function placeAsset(assetPath: string, config?: PlacementConfig, image?: {
+    readonly width: number;
+    readonly height: number;
+}): Placement;
+/** Resolves a placement to concrete coordinates for an image of known size. */
+export declare function placementOrigin(placement: Placement, image: {
+    readonly width: number;
+    readonly height: number;
+}, canvas: {
+    readonly width: number;
+    readonly height: number;
+}): Placed | undefined;

package/dist/layout/assetPlacement.js

@@ -0,0 +1,104 @@
+import { defaultCrownConfig, defaultNicknameConfig } from "../schema/frame.js";
+/** Where the PT plate sits when a layout does not say. */
+export const DEFAULT_PT_IMAGE = { x: 2441, y: 3847 };
+/** The crown's black bar is fixed art at a fixed place. */
+export const CROWN_BLACK_BAR = {
+    x: 220,
+    y: 200,
+    width: 2815,
+    height: 140,
+};
+/** Horizontal fallback for the nyx insert when the crown's width is unknown. */
+export const NYX_INSERT_FALLBACK_X = 611;
+/** First segment of a dotted asset path, e.g. `crown` in `crown.nickname`. */
+const familyOf = (assetPath) => assetPath.split(".")[0] ?? assetPath;
+/**
+ * Where an asset is drawn on the sheet.
+ *
+ * Most frame art is full-sheet and simply centres, but several families do
+ * not: crowns, nicknames and the PT plate are placed from the layout's own
+ * render config, and drawing them centred — as a naive compositor does — puts
+ * a legendary crown in the middle of the card. The positions here mirror
+ * Card Anvil's `konva/nodes/imageNodes.ts`, which is the authority.
+ *
+ * `assetPath` is the dotted path within a `FrameAssets`, as `walkAssets`
+ * reports it: `base.w`, `crown.nickname`, `pt.u`, and so on.
+ */
+export function placeAsset(assetPath, config = {}, image) {
+    const family = familyOf(assetPath);
+    const leaf = assetPath.split(".").slice(1).join(".");
+    switch (family) {
+        // Full-sheet art.
+        case "base":
+        case "land":
+        case "nyx":
+        case "tall":
+        case "creature":
+        case "tokenTitle":
+        case "extendedOverlay":
+            return { kind: "center" };
+        case "black":
+            return { kind: "at", at: { x: CROWN_BLACK_BAR.x, y: CROWN_BLACK_BAR.y } };
+        case "dfcIcon":
+        case "dfcIconSet":
+        case "dfcIconColorSet":
+            return { kind: "at", at: { x: 0, y: 0 } };
+        case "crown": {
+            const crown = config.crownConfig ?? defaultCrownConfig;
+            const nicknamed = config.hasNickname === true;
+            const x = (nicknamed ? crown.nicknameCrownX : undefined) ?? crown.x;
+            const y = (nicknamed ? crown.nicknameCrownY : undefined) ?? crown.y;
+            // The nyx insert sits just inside the crown it decorates.
+            if (leaf.startsWith("nyxInsert")) {
+                const insetX = crown.nyxInsertX ??
+                    (image
+                        ? x + (CROWN_BLACK_BAR.width - image.width) / 2
+                        : NYX_INSERT_FALLBACK_X);
+                const insetY = (nicknamed ? crown.nyxInsertNicknameY : undefined) ??
+                    crown.nyxInsertY ??
+                    y + 2;
+                return { kind: "at", at: { x: insetX, y: insetY } };
+            }
+            return { kind: "at", at: { x, y } };
+        }
+        case "nickname": {
+            const nickname = config.nicknameConfig ?? defaultNicknameConfig;
+            return { kind: "at", at: { x: nickname.x, y: nickname.y } };
+        }
+        case "pt": {
+            const pt = config.ptImage ?? DEFAULT_PT_IMAGE;
+            return { kind: "at", at: { x: pt.x, y: pt.y } };
+        }
+        case "planeswalker":
+            return {
+                kind: "dynamic",
+                reason: "ability rows are laid out from the card's ability count",
+            };
+        case "saga":
+            return {
+                kind: "dynamic",
+                reason: "chapter badges are laid out from the card's chapter count",
+            };
+        case "flipside":
+            return {
+                kind: "dynamic",
+                reason: "positioned from the other face's power/toughness",
+            };
+        default:
+            return { kind: "center" };
+    }
+}
+/** Resolves a placement to concrete coordinates for an image of known size. */
+export function placementOrigin(placement, image, canvas) {
+    switch (placement.kind) {
+        case "center":
+            return {
+                x: (canvas.width - image.width) / 2,
+                y: (canvas.height - image.height) / 2,
+            };
+        case "at":
+            return placement.at;
+        default:
+            return undefined;
+    }
+}

package/dist/layout/decorations.d.ts

@@ -0,0 +1,78 @@
+import type { FrameAssets, FrameColor } from "../schema/frameAssets.js";
+import { type FrameDetails } from "./frameLayers.js";
+/**
+ * The type-line facts the decoration colours turn on.
+ *
+ * A `CardShape` satisfies this structurally, and so does a card the app has
+ * already read a type line from.
+ */
+export interface DecorationFacts {
+    readonly isLand?: boolean;
+    readonly isArtifact?: boolean;
+    readonly isVehicle?: boolean;
+}
+/** One colour, or the two halves of a two-colour banner. */
+export type BannerColors = FrameColor | [FrameColor, FrameColor];
+/**
+ * The colour a card's banners take.
+ *
+ * Driven by the resolved identity rather than the background, so a crown, a
+ * nickname plate and a PT box on the same card always agree with each other
+ * and with the pinlines.
+ */
+export declare function identityColors(details: FrameDetails, facts?: DecorationFacts): BannerColors;
+/** Legendary crown colour(s). */
+export declare function crownColors(details: FrameDetails, facts?: DecorationFacts): BannerColors;
+/**
+ * Nickname banner colour(s).
+ *
+ * A land with no resolved identity uses the dedicated land nickname art rather
+ * than the colourless one.
+ */
+export declare function nicknameColors(details: FrameDetails, facts?: DecorationFacts): BannerColors;
+/**
+ * PT box colour.
+ *
+ * Only a true two-colour hybrid takes the colourless box. A card built from
+ * monocoloured-hybrid pips in three or more colours is an ordinary gold card
+ * and must resolve by identity length instead.
+ */
+export declare function ptBoxColor(details: FrameDetails, facts?: DecorationFacts): FrameColor;
+/** Combined crown + nickname banner; the UB variant falls back to the plain one. */
+export declare function resolveCrownNicknameAsset(assets: FrameAssets, color: FrameColor, useUBCrowns: boolean): string | undefined;
+/**
+ * Legendary crown art.
+ *
+ * A nicknamed card prefers the combined crown+nickname asset, and falls back
+ * to the plain crown when a frame does not ship one.
+ */
+export declare function resolveCrownAsset(assets: FrameAssets, color: FrameColor, opts: {
+    nickname: boolean;
+    useUBCrowns: boolean;
+}): string | undefined;
+export declare function resolveNicknameAsset(assets: FrameAssets, color: FrameColor): string | undefined;
+export declare function resolvePtBoxAsset(assets: FrameAssets, color: FrameColor): string | undefined;
+export declare function resolveNyxInsertAsset(assets: FrameAssets, color: FrameColor, useUBCrowns?: boolean): string | undefined;
+/** What a card is, for deciding which banners it gets. */
+export interface DecorationCard {
+    readonly isLegendary?: boolean;
+    /** The nickname text; a card has a nickname when this is non-empty. */
+    readonly nickname?: string;
+    readonly power?: string;
+    readonly toughness?: string;
+}
+export interface DecorationState {
+    readonly crown: boolean;
+    /** The bar behind the crown, drawn on the same condition. */
+    readonly crownBlackBar: boolean;
+    readonly nickname: boolean;
+    readonly ptBox: boolean;
+}
+/**
+ * Which banners a card draws.
+ *
+ * Mirrors the renderer's conditions: crowns are legendary-only, the nickname
+ * plate needs nickname text, and the PT box needs *both* a power and a
+ * toughness — a card with only one is not a creature and gets no plate.
+ */
+export declare function decorationsFor(card: DecorationCard): DecorationState;