@ludic-labs/assembly 0.0.0-stage → 0.4.0

package/dist/sprite-format.d.ts

@@ -0,0 +1,4 @@
+import type { SpriteDocument } from "./sprite-types.js";
+export declare function formatSprite(value: unknown, indent?: string, key?: string | null): string;
+/** Rename authored owners without merging parts; notes are keyed by the original name. */
+export declare function renameParts(input: SpriteDocument, requested: Record<string, string>, notes?: Record<string, string>): SpriteDocument;

package/dist/sprite-format.js

@@ -0,0 +1,155 @@
+const WIDTH = 110;
+export function formatSprite(value, indent = "", key = null) {
+    const pad = `${indent}  `;
+    if (Array.isArray(value)) {
+        if (key === "pixels" && value.length > 1)
+            return `[\n${value.map((r) => `${pad}${JSON.stringify(r)}`).join(",\n")}\n${indent}]`;
+        const inline = `[${value.map((v) => formatSprite(v)).join(", ")}]`;
+        if (inline.length + indent.length <= WIDTH &&
+            !value.some((v) => v && typeof v === "object" && !Array.isArray(v)))
+            return inline;
+        return `[\n${value.map((v) => `${pad}${formatSprite(v, pad)}`).join(",\n")}\n${indent}]`;
+    }
+    if (value && typeof value === "object") {
+        const entries = Object.entries(value);
+        if (!entries.length)
+            return "{}";
+        const inline = `{ ${entries.map(([k, v]) => `${JSON.stringify(k)}: ${formatSprite(v, "", k)}`).join(", ")} }`;
+        if (!inline.includes("\n") &&
+            inline.length + indent.length <= WIDTH &&
+            !("pixels" in value &&
+                Array.isArray(value.pixels) &&
+                value.pixels.length > 1))
+            return inline;
+        return `{\n${entries.map(([k, v]) => `${pad}${JSON.stringify(k)}: ${formatSprite(v, pad, k)}`).join(",\n")}\n${indent}}`;
+    }
+    return JSON.stringify(value) ?? "null";
+}
+/** Rename authored owners without merging parts; notes are keyed by the original name. */
+export function renameParts(input, requested, notes = {}) {
+    const doc = structuredClone(input);
+    const used = new Set();
+    const record = (v) => {
+        if (typeof v === "string")
+            used.add(v);
+    };
+    const eachLayer = (visit) => {
+        const lists = [
+            ...Object.values(doc.cels ?? {}).map((c) => c?.layers),
+            ...Object.values(doc.recipes ?? {}),
+        ];
+        for (const layers of lists)
+            if (Array.isArray(layers))
+                for (const l of layers)
+                    if (l && typeof l === "object" && !Array.isArray(l))
+                        visit(l);
+    };
+    if (Array.isArray(doc.parts))
+        doc.parts.forEach(record);
+    else if (doc.parts && typeof doc.parts === "object")
+        Object.keys(doc.parts).forEach(record);
+    eachLayer((l) => {
+        if (l.shade && typeof l.shade === "object" && !Array.isArray(l.shade))
+            Object.keys(l.shade).forEach(record);
+        record(l.part);
+        record(l.onPart);
+        record(l.at?.part);
+        for (const k of ["parts", "through"])
+            if (Array.isArray(l[k]))
+                l[k].forEach(record);
+        if (l.part === undefined) {
+            if (Array.isArray(l.silhouette))
+                l.silhouette.forEach(record);
+            else
+                record(l.silhouette);
+        }
+    });
+    for (const c of Object.values(doc.cels ?? {}))
+        if (Array.isArray(c?.exempt))
+            c.exempt.forEach(record);
+    const mapping = new Map();
+    const taken = new Set([...used].filter((n) => !Object.hasOwn(requested, n)));
+    const targets = new Set(Object.values(requested));
+    for (const [from, to] of Object.entries(requested)) {
+        if (typeof to !== "string")
+            throw new TypeError("part names must be strings");
+        let name = to;
+        for (let i = 2; taken.has(name) || (name !== to && targets.has(name)); i++)
+            name = `${to}-${i}`;
+        mapping.set(from, name);
+        taken.add(name);
+    }
+    const map = (v) => (typeof v === "string" ? (mapping.get(v) ?? v) : v);
+    const list = (v) => (Array.isArray(v) ? [...new Set(v.map(map))] : v);
+    eachLayer((l) => {
+        if (l.shade !== undefined) {
+            // Shade map keys and parts name authored owners; guide masks keep their original names.
+            let names = Array.isArray(l.parts) ? l.parts : null;
+            if (!names && l.shade === true)
+                names = Object.keys(doc.parts ?? {}).filter((n) => doc.parts[n]?.ramps?.length);
+            if (!names && l.shade && typeof l.shade === "object")
+                names = Object.keys(l.shade);
+            if (names?.some((n) => mapping.has(n))) {
+                const guides = { ...l.guides };
+                for (const n of names)
+                    guides[n] = l.guides?.[n] ?? n;
+                l.guides = guides;
+            }
+            if (l.shade && typeof l.shade === "object" && !Array.isArray(l.shade))
+                l.shade = Object.fromEntries(Object.entries(l.shade).map(([n, ramp]) => [map(n), ramp]));
+            if (l.guides)
+                l.guides = Object.fromEntries(Object.entries(l.guides).map(([n, guide]) => [map(n), guide]));
+        }
+        // A silhouette's guide reference stays fixed; its implicit owner is renamed explicitly.
+        if (l.part === undefined && l.silhouette !== undefined) {
+            const names = typeof l.silhouette === "string" ? [l.silhouette] : l.silhouette;
+            if (Array.isArray(names) && names.length === 1 && mapping.has(names[0]))
+                l.part = names[0];
+            else if (Array.isArray(names) && names.some((n) => mapping.has(n))) {
+                // Split below: each guide mask retains its original ownership after mapping.
+                l.__spriteRename = names.map((n) => ({ ...l, silhouette: n, part: map(n) }));
+            }
+        }
+        if (Object.hasOwn(l, "part"))
+            l.part = map(l.part);
+        for (const k of ["parts", "through"])
+            if (Object.hasOwn(l, k))
+                l[k] = list(l[k]);
+        if (typeof l.onPart === "string")
+            l.onPart = map(l.onPart);
+        if (l.at && typeof l.at === "object" && !Array.isArray(l.at) && Object.hasOwn(l.at, "part"))
+            l.at.part = map(l.at.part);
+    });
+    const expand = (layers) => layers.flatMap((l) => l?.__spriteRename ?? [l]);
+    for (const c of Object.values(doc.cels ?? {})) {
+        if (Array.isArray(c?.layers))
+            c.layers = expand(c.layers);
+        if (Array.isArray(c?.exempt))
+            c.exempt = list(c.exempt);
+    }
+    for (const [name, layers] of Object.entries(doc.recipes ?? {}))
+        if (Array.isArray(layers))
+            doc.recipes[name] = expand(layers);
+    const declarations = Object.create(null);
+    if (Array.isArray(doc.parts))
+        for (const n of doc.parts)
+            declarations[String(map(n))] = {};
+    else
+        for (const [n, spec] of Object.entries(doc.parts ?? {}))
+            declarations[String(map(n))] = spec;
+    const described = Object.entries(notes).filter(([from]) => mapping.has(from));
+    if (described.length) {
+        for (const n of used)
+            declarations[String(map(n))] ??= {};
+        for (const [from, text] of described) {
+            const name = String(map(from));
+            declarations[name] = { ...declarations[name], notes: text };
+        }
+        doc.parts = declarations;
+    }
+    else if (Array.isArray(doc.parts))
+        doc.parts = list(doc.parts);
+    else if (doc.parts && typeof doc.parts === "object")
+        doc.parts = declarations;
+    return doc;
+}

package/dist/sprite-guide.d.ts

@@ -0,0 +1,40 @@
+import type { CompiledAsset } from "./types.js";
+import type { CompileSpriteOptions, SpriteGuidePart, SpriteView, SpriteRenderSpec } from "./sprite-types.js";
+/** Empty pixels around render bases and layout guides, so the two agree on canvas size. */
+export declare const DEFAULT_MARGIN = 2;
+/**
+ * The asset in a sampled pose of one of its motion clips, `{ clip, phase }`,
+ * or the rest pose when `pose` is null.
+ */
+export declare function posedAsset(asset: CompiledAsset, motionJson: unknown, pose: unknown, path?: string): CompiledAsset;
+/** Renders a compiled asset; `fitHeight` searches the density that gives that many rows. */
+export declare function renderSpriteBase(asset: CompiledAsset, spec: SpriteRenderSpec): import("./pixel.js").PixelImage;
+/** Builds the `renderBase` option of compileSprite for documents that name `asset`. */
+export declare function spriteRenderResolver(asset: CompiledAsset): NonNullable<CompileSpriteOptions["renderBase"]>;
+/**
+ * Layout guide for one view of a compiled asset: the canvas the /pixel
+ * renderer would use at this density, and per part (merged across sides and
+ * repeats) and per instance id: visible bounding box, visible area, depth rank
+ * (0 = nearest) and visible pixel mask. Parts with no visible pixels are
+ * `hidden` when their projection covers at least one pixel (occluded) and are
+ * listed with `subpixel: true` otherwise (too small to show at this density).
+ */
+export declare function layoutGuide(asset: CompiledAsset, view: SpriteView): {
+    width: number;
+    height: number;
+    pixelsPerMetre: number;
+    camera: string;
+    parts: Record<string, SpriteGuidePart>;
+    hidden: string[];
+    cut: string[];
+    owners: Int32Array<ArrayBufferLike>;
+    depth: Float32Array<ArrayBufferLike>;
+    roles: Int8Array<ArrayBufferLike>;
+    instances: string[];
+    originX: number;
+    originY: number;
+};
+/** Builds the `guide` option of compileSprite for documents that name `asset`. */
+export declare function spriteGuideResolver(asset: CompiledAsset, { motion }?: {
+    motion?: unknown;
+}): NonNullable<CompileSpriteOptions["guide"]>;

package/dist/sprite-guide.js

@@ -0,0 +1,330 @@
+import { PIXEL_CAMERAS, PIXEL_PROFILES, pixelCamera, pixelInstances, renderPixelArt } from "./pixel.js";
+import { compileMotion, poseAsset, samplePose } from "./motion.js";
+import { requireValue } from "./required.js";
+const RENDER_FIELDS = ["camera", "pixelsPerMetre", "fitHeight", "margin", "profile", "features", "snap"];
+/** Empty pixels around render bases and layout guides, so the two agree on canvas size. */
+export const DEFAULT_MARGIN = 2;
+const fail = (code, path, message) => Object.assign(new Error(message), { diagnostics: [{ severity: "error", code, path, message }] });
+/**
+ * The asset in a sampled pose of one of its motion clips, `{ clip, phase }`,
+ * or the rest pose when `pose` is null.
+ */
+export function posedAsset(asset, motionJson, pose, path = "/pose") {
+    if (!pose)
+        return asset;
+    const bad = (message) => Object.assign(new Error(message), {
+        diagnostics: [{ severity: "error", code: "SPRITE_VIEW_POSE", path, message }],
+    });
+    if (typeof pose !== "object" ||
+        Array.isArray(pose) ||
+        !("clip" in pose) ||
+        typeof pose.clip !== "string" ||
+        !("phase" in pose) ||
+        typeof pose.phase !== "number" ||
+        !Number.isFinite(pose.phase))
+        throw bad("pose is { clip, phase } with a clip name and a finite phase");
+    const extra = Object.keys(pose).filter((k) => !["clip", "phase"].includes(k));
+    if (extra.length)
+        throw bad(`unknown pose field ${extra[0]}`);
+    if (!motionJson)
+        throw bad("the asset has no motion set");
+    const motion = compileMotion(motionJson, asset);
+    const clip = Object.hasOwn(motion.clips, pose.clip) ? motion.clips[pose.clip] : null;
+    if (!clip)
+        throw bad(`the asset's motion set has no clip ${pose.clip}`);
+    return poseAsset(asset, samplePose(asset, clip, { phase: pose.phase }));
+}
+function bboxHeight(img) {
+    let y0 = Infinity, y1 = -Infinity;
+    for (let y = 0; y < img.height; y++)
+        for (let x = 0; x < img.width; x++)
+            if (img.rgba[(y * img.width + x) * 4 + 3]) {
+                y0 = Math.min(y0, y);
+                y1 = Math.max(y1, y);
+            }
+    return y1 - y0 + 1;
+}
+/** Renders a compiled asset; `fitHeight` searches the density that gives that many rows. */
+export function renderSpriteBase(asset, spec) {
+    if (spec.pixelsPerMetre !== undefined && !(Number.isFinite(spec.pixelsPerMetre) && spec.pixelsPerMetre > 0))
+        throw fail("PIXEL_DENSITY", "/pixelsPerMetre", "pixelsPerMetre must be a positive number");
+    const camera = typeof spec.camera === "string"
+        ? PIXEL_CAMERAS[spec.camera]
+        : spec.camera
+            ? pixelCamera(spec.camera.yaw, spec.camera.pitch)
+            : PIXEL_CAMERAS.front;
+    if (!camera)
+        throw new Error(`unknown camera ${spec.camera}`);
+    const profile = Object.hasOwn(PIXEL_PROFILES, spec.profile ?? "arcade")
+        ? PIXEL_PROFILES[(spec.profile ?? "arcade")]
+        : null;
+    if (!profile)
+        throw new Error(`unknown profile ${spec.profile}`);
+    const base = { camera, profile, margin: spec.margin ?? DEFAULT_MARGIN, features: spec.features ?? [] };
+    // Densities stay inside the renderer's accepted range (0, 512].
+    const draw = (ppm) => renderPixelArt(pixelInstances(asset), { ...base, pixelsPerMetre: Math.min(512, Math.max(0.25, ppm)) });
+    if (spec.fitHeight === undefined)
+        return draw(spec.pixelsPerMetre ?? 32);
+    if (!Number.isInteger(spec.fitHeight) || spec.fitHeight < 1 || spec.fitHeight > 1024)
+        throw fail("SPRITE_FIT_HEIGHT", "/fitHeight", "fitHeight must be an integer within 1..1024");
+    // Proportional steps, then a fine scan around the estimate; fail rather than return another height.
+    let ppm = 32;
+    let img = draw(ppm);
+    for (let i = 0; i < 6 && bboxHeight(img) !== spec.fitHeight; i++) {
+        ppm *= spec.fitHeight / bboxHeight(img);
+        img = draw(ppm);
+    }
+    for (let k = 1; k <= 200 && bboxHeight(img) !== spec.fitHeight; k++) {
+        const trial = ppm * (1 + (k % 2 ? 1 : -1) * Math.ceil(k / 2) * 0.002);
+        const t = draw(trial);
+        if (bboxHeight(t) === spec.fitHeight)
+            img = t;
+    }
+    if (bboxHeight(img) !== spec.fitHeight)
+        throw fail("SPRITE_FIT_HEIGHT", "/fitHeight", `no density gives exactly ${spec.fitHeight} rows`);
+    return img;
+}
+/** Builds the `renderBase` option of compileSprite for documents that name `asset`. */
+export function spriteRenderResolver(asset) {
+    return (spec, path) => {
+        const extra = Object.keys(spec).filter((k) => !RENDER_FIELDS.includes(k));
+        if (extra.length)
+            throw Object.assign(new Error("unknown render field"), {
+                diagnostics: [
+                    {
+                        severity: "error",
+                        code: "SPRITE_UNKNOWN_FIELD",
+                        path: `${path}/${String(extra[0]).replace(/~/g, "~0").replace(/\//g, "~1")}`,
+                        message: `unknown render field ${extra[0]}`,
+                    },
+                ],
+            });
+        const img = renderSpriteBase(asset, spec);
+        return {
+            width: img.width,
+            height: img.height,
+            rgba: img.rgba,
+            owners: img.owners,
+            names: img.instances.map((i) => i.part),
+        };
+    };
+}
+const VIEW_FIELDS = ["camera", "pixelsPerMetre", "margin", "notes", "hide", "pose"];
+/** An instance is cut from a view when its part, its id or an id prefix ("wall/") is listed. */
+const isCut = (inst, hide) => hide.some((h) => h === inst.part || h === inst.id || (h.endsWith("/") && inst.id.startsWith(h)));
+const dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+/**
+ * Layout guide for one view of a compiled asset: the canvas the /pixel
+ * renderer would use at this density, and per part (merged across sides and
+ * repeats) and per instance id: visible bounding box, visible area, depth rank
+ * (0 = nearest) and visible pixel mask. Parts with no visible pixels are
+ * `hidden` when their projection covers at least one pixel (occluded) and are
+ * listed with `subpixel: true` otherwise (too small to show at this density).
+ */
+export function layoutGuide(asset, view) {
+    if (!(Number.isFinite(view.pixelsPerMetre) && view.pixelsPerMetre > 0))
+        throw fail("PIXEL_DENSITY", "/pixelsPerMetre", "pixelsPerMetre must be a positive number");
+    const camera = typeof view.camera === "string"
+        ? PIXEL_CAMERAS[view.camera]
+        : pixelCamera(view.camera.yaw, view.camera.pitch);
+    if (!camera)
+        throw new Error(`unknown camera ${view.camera}`);
+    const ppm = Math.min(512, Math.max(0.25, view.pixelsPerMetre));
+    const margin = view.margin ?? DEFAULT_MARGIN;
+    const hide = view.hide ?? [];
+    const all = pixelInstances(asset);
+    const instances = all.filter((inst) => !isCut(inst, hide));
+    const cut = [
+        ...new Set(all.filter((inst) => isCut(inst, hide)).map((inst) => inst.part)),
+    ].sort();
+    const img = renderPixelArt(instances, {
+        camera,
+        profile: PIXEL_PROFILES.arcade,
+        pixelsPerMetre: ppm,
+        margin,
+    });
+    // Same framing as renderPixelArt, to project parts that are not visible.
+    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+    for (const { mesh } of instances)
+        for (let v = 0; v < mesh.positions.length; v += 3) {
+            const p = [
+                requireValue(mesh.positions[v]),
+                requireValue(mesh.positions[v + 1]),
+                requireValue(mesh.positions[v + 2]),
+            ];
+            minX = Math.min(minX, dot3(p, camera.right));
+            maxX = Math.max(maxX, dot3(p, camera.right));
+            minY = Math.min(minY, dot3(p, camera.up));
+            maxY = Math.max(maxY, dot3(p, camera.up));
+        }
+    const originX = minX - Math.floor((img.width - (maxX - minX) * ppm) / 2) / ppm;
+    const originY = maxY + Math.floor((img.height - (maxY - minY) * ppm) / 2) / ppm;
+    const entries = new Map();
+    const entry = (name, instance) => {
+        if (!entries.has(name))
+            entries.set(name, { mask: [], proj: [Infinity, Infinity, -Infinity, -Infinity], close: [], instance });
+        return requireValue(entries.get(name));
+    };
+    instances.forEach((inst, i) => {
+        const names = inst.id === inst.part
+            ? [[inst.part, false]]
+            : [
+                [inst.part, false],
+                [inst.id, true],
+            ];
+        let cx = 0;
+        const n = inst.mesh.positions.length / 3;
+        const pr = [Infinity, Infinity, -Infinity, -Infinity];
+        const screen = [];
+        for (let v = 0; v < inst.mesh.positions.length; v += 3) {
+            const p = [
+                requireValue(inst.mesh.positions[v]),
+                requireValue(inst.mesh.positions[v + 1]),
+                requireValue(inst.mesh.positions[v + 2]),
+            ];
+            const x = (dot3(p, camera.right) - originX) * ppm, y = (originY - dot3(p, camera.up)) * ppm;
+            pr[0] = Math.min(pr[0], x);
+            pr[1] = Math.min(pr[1], y);
+            pr[2] = Math.max(pr[2], x);
+            pr[3] = Math.max(pr[3], y);
+            screen.push(x, y);
+            cx += dot3(p, camera.back);
+        }
+        // Projected area in square pixels: tells "too small to rasterise" from "occluded".
+        let area = 0;
+        const idx = inst.mesh.indices;
+        for (let t = 0; t + 2 < idx.length; t += 3) {
+            const [a, b, c] = [
+                requireValue(idx[t]) * 2,
+                requireValue(idx[t + 1]) * 2,
+                requireValue(idx[t + 2]) * 2,
+            ];
+            area +=
+                Math.abs((requireValue(screen[b]) - requireValue(screen[a])) *
+                    (requireValue(screen[c + 1]) - requireValue(screen[a + 1])) -
+                    (requireValue(screen[c]) - requireValue(screen[a])) *
+                        (requireValue(screen[b + 1]) - requireValue(screen[a + 1]))) / 2;
+        }
+        for (const [name, instance] of names) {
+            const e = entry(name, instance);
+            e.proj = [
+                Math.min(e.proj[0], pr[0]),
+                Math.min(e.proj[1], pr[1]),
+                Math.max(e.proj[2], pr[2]),
+                Math.max(e.proj[3], pr[3]),
+            ];
+            e.close.push(cx / Math.max(1, n));
+            e.area = (e.area ?? 0) + area;
+            e.index ??= [];
+            e.index.push(i);
+        }
+    });
+    for (let q = 0; q < img.owners.length; q++) {
+        const o = requireValue(img.owners[q]);
+        if (o < 0)
+            continue;
+        const inst = requireValue(instances[o]);
+        entry(inst.part, false).mask.push(q);
+        if (inst.id !== inst.part)
+            entry(inst.id, true).mask.push(q);
+    }
+    // Mean distance toward the camera (metres along camera.back) of a part's
+    // instances: scenes composite parts by it, so an open door can be in front
+    // of a neighbour while its cabinet stays behind.
+    const meanZ = (e) => +(e.close.reduce((a, b) => a + b, 0) / Math.max(1, e.close.length)).toFixed(6);
+    const parts = Object.create(null);
+    const hidden = [];
+    const closeness = [...entries.entries()]
+        .filter(([, e]) => !e.instance)
+        .map(([name, e]) => [name, Math.max(...e.close)])
+        .sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1));
+    const rank = new Map(closeness.map(([name], i) => [name, i]));
+    for (const [name, e] of [...entries.entries()].sort((a, b) => (a[0] < b[0] ? -1 : 1))) {
+        const [px0, py0, px1, py1] = e.proj;
+        const projected = [
+            Math.floor(px0),
+            Math.floor(py0),
+            Math.max(1, Math.ceil(px1) - Math.floor(px0)),
+            Math.max(1, Math.ceil(py1) - Math.floor(py0)),
+        ];
+        const base = name.split("/")[0];
+        if (!e.mask.length) {
+            if ((e.area ?? 0) >= 1) {
+                hidden.push(name);
+                continue;
+            }
+            parts[name] = {
+                bbox: projected,
+                projected,
+                area: 0,
+                depth: rank.get(requireValue(base)) ?? 0,
+                z: meanZ(e),
+                mask: [],
+                subpixel: true,
+                instance: e.instance,
+            };
+            continue;
+        }
+        let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+        for (const q of e.mask) {
+            const x = q % img.width, y = Math.floor(q / img.width);
+            x0 = Math.min(x0, x);
+            y0 = Math.min(y0, y);
+            x1 = Math.max(x1, x);
+            y1 = Math.max(y1, y);
+        }
+        parts[name] = {
+            bbox: [x0, y0, x1 - x0 + 1, y1 - y0 + 1],
+            projected,
+            area: e.mask.length,
+            depth: rank.get(requireValue(base)) ?? 0,
+            z: meanZ(e),
+            mask: e.mask,
+            instance: e.instance,
+        };
+    }
+    return {
+        width: img.width,
+        height: img.height,
+        pixelsPerMetre: ppm,
+        camera: camera.name,
+        parts,
+        // Occluded parts, then parts cut from this view: drawing either is reported.
+        hidden: [...hidden, ...cut.filter((n) => !Object.hasOwn(parts, n) && !hidden.includes(n))],
+        cut,
+        owners: img.owners,
+        // Per pixel: distance toward the camera (metres along camera.back, in the
+        // asset's frame) of the visible surface, NaN where empty.
+        depth: img.depth,
+        // Per pixel: the light tone of the visible surface (/pixel roles), for `shade`.
+        roles: img.roles,
+        instances: instances.map((i) => i.id),
+        // World position of the canvas's top-left corner along camera right and up
+        // (metres): a scene places this cel at (originX, originY) plus its
+        // placement's projected translation.
+        originX,
+        originY,
+    };
+}
+/** Builds the `guide` option of compileSprite for documents that name `asset`. */
+export function spriteGuideResolver(asset, { motion = null } = {}) {
+    return (view, path) => {
+        const extra = Object.keys(view).filter((k) => !VIEW_FIELDS.includes(k));
+        const bad = extra.length
+            ? `unknown view field ${extra[0]}`
+            : !(Number.isFinite(view.pixelsPerMetre) && view.pixelsPerMetre > 0)
+                ? "pixelsPerMetre must be a positive number"
+                : !view.camera
+                    ? "camera is required"
+                    : view.hide !== undefined &&
+                        !(Array.isArray(view.hide) && view.hide.every((h) => typeof h === "string" && h))
+                        ? "hide is a list of part names or instance ids"
+                        : null;
+        if (bad)
+            throw Object.assign(new Error(bad), {
+                diagnostics: [{ severity: "error", code: "SPRITE_VIEW", path, message: bad }],
+            });
+        const posed = posedAsset(asset, motion, view.pose, `${path}/pose`);
+        return layoutGuide(posed, view);
+    };
+}