summer-engine 3.0.0 → 3.2.0

package/dist/core/capabilities/audit/gaps.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Judgment for the gap detectors of summer_scene_audit. The kernel
+ * measures; this file decides.
+ *
+ * - exposed_edge (A): open outline edges of walls and facade members (bands,
+ *   piers, joints: the kernel's geometric roles) that nothing covers within
+ *   4-7 mm, seen from walkable space, with a 2-60 cm reveal behind them or a
+ *   coplanar continuation within 4 cm (seam) or 35 cm (bridged gap).
+ * - open_fixture_end: open ends of run pieces (two or more open rims of one
+ *   size) nothing joins within a sleeve tolerance, seen from the open side.
+ * - depth_step (C): runs of recessed or proud depth along each facade row.
+ *
+ * Severity: exposed_edge warns on band pieces (and on walls when depth_step
+ * agrees), else look; open_fixture_end warns; depth_step is look, and a
+ * depth_step hole next to a through_hole confirms it (warn -> error). A
+ * confirming flag is folded into the issue it confirms.
+ */
+import { type Vec3 } from "../seeing/math.js";
+import type { AuditCheck } from "./args.js";
+import type { AuditIssue, InstRow, KernelResult } from "./judge.js";
+import { type Box } from "./math.js";
+export declare const CONFIRM_RADIUS = 0.6;
+/** exposed_edge classes that count (sky, far and mixed are silhouettes, not gaps). */
+export declare const EDGE_CLASSES: Set<string>;
+export interface GkLine {
+    b: number;
+    ax: 0 | 2;
+    c: number;
+    lo: number;
+    hi: number;
+    y0: number;
+    y1: number;
+    tmin: number;
+    tmax: number;
+    sides: number[];
+    pieces: number[];
+}
+export interface EdgeFlag {
+    owner: number;
+    cls: string;
+    len: number;
+    n: number;
+    c: Vec3;
+    box: Box;
+    step: number;
+    counts: {
+        gap: number;
+        seam: number;
+        bridge: number;
+        sky: number;
+        far: number;
+    };
+    eye: Vec3;
+    hit: number;
+}
+export interface FixtureEnd {
+    i: number;
+    c: Vec3;
+    out: Vec3;
+    r: number;
+    eye: Vec3;
+}
+export interface DepthFlag {
+    kind: string;
+    line: number;
+    side: number;
+    s0: number;
+    s1: number;
+    y0: number;
+    y1: number;
+    rows: number;
+    depth: number;
+    c: Vec3;
+}
+export declare function parseGkLines(raw: unknown): GkLine[];
+/** Door-like openings the kernel found (inserts reaching the floor, 1.8 m
+ *  or taller): world boxes. */
+export declare function parseDoors(raw: unknown): Box[];
+export declare function parseEdgeFlags(raw: unknown): EdgeFlag[];
+export declare function parseFixtureEnds(raw: unknown): FixtureEnd[];
+export declare function parseDepthFlags(raw: unknown): DepthFlag[];
+export declare function instBox(r: InstRow): Box;
+/** The world box a depth_step run covers (its rows, 10 cm deep at the facade). */
+export declare function depthBox(f: DepthFlag, lines: readonly GkLine[]): Box;
+export interface GapJudgement {
+    issues: AuditIssue[];
+    /** Checks that ran but could measure nothing (no walkable eye points). */
+    unmeasured: AuditCheck[];
+    notes: string[];
+}
+/**
+ * exposed_edge, open_fixture_end and depth_step issues,
+ * with confirmation folded in. `holes` (the through_hole issues) are
+ * updated in place when a depth_step hole confirms one.
+ */
+export declare function judgeGaps(result: KernelResult, inst: readonly InstRow[], want: ReadonlySet<AuditCheck>, holes?: AuditIssue[]): GapJudgement;

package/dist/core/capabilities/audit/gaps.js

@@ -0,0 +1,257 @@
+/**
+ * Judgment for the gap detectors of summer_scene_audit. The kernel
+ * measures; this file decides.
+ *
+ * - exposed_edge (A): open outline edges of walls and facade members (bands,
+ *   piers, joints: the kernel's geometric roles) that nothing covers within
+ *   4-7 mm, seen from walkable space, with a 2-60 cm reveal behind them or a
+ *   coplanar continuation within 4 cm (seam) or 35 cm (bridged gap).
+ * - open_fixture_end: open ends of run pieces (two or more open rims of one
+ *   size) nothing joins within a sleeve tolerance, seen from the open side.
+ * - depth_step (C): runs of recessed or proud depth along each facade row.
+ *
+ * Severity: exposed_edge warns on band pieces (and on walls when depth_step
+ * agrees), else look; open_fixture_end warns; depth_step is look, and a
+ * depth_step hole next to a through_hole confirms it (warn -> error). A
+ * confirming flag is folded into the issue it confirms.
+ */
+import { add, distance, normalize, scale, sub } from "../seeing/math.js";
+import { boxCenter, boxDistance, boxIntersection, growBox, makeBox } from "./math.js";
+export const CONFIRM_RADIUS = 0.6;
+/** exposed_edge classes that count (sky, far and mixed are silhouettes, not gaps). */
+export const EDGE_CLASSES = new Set(["gap", "seam", "bridge"]);
+// ---------------------------------------------------------------------------
+// Parsing
+// ---------------------------------------------------------------------------
+const r2 = (n) => Math.round(n * 100) / 100 || 0;
+const r3 = (n) => Math.round(n * 1000) / 1000 || 0;
+const v2 = (v) => [r2(v[0]), r2(v[1]), r2(v[2])];
+const fmt = (v) => `(${r2(v[0])},${r2(v[1])},${r2(v[2])})`;
+const cm = (m) => `${Math.round(m * 1000) / 10} cm`;
+function num(v, fallback = 0) {
+    return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function vec(v) {
+    return Array.isArray(v) && v.length >= 3 ? [num(v[0]), num(v[1]), num(v[2])] : [0, 0, 0];
+}
+function arr(v) {
+    return Array.isArray(v) ? v : [];
+}
+function obj(v) {
+    return v && typeof v === "object" && !Array.isArray(v) ? v : {};
+}
+export function parseGkLines(raw) {
+    return arr(obj(raw).lines).map((l) => {
+        const r = obj(l);
+        return {
+            b: num(r.b, -1),
+            ax: num(r.ax) === 2 ? 2 : 0,
+            c: num(r.c),
+            lo: num(r.lo),
+            hi: num(r.hi),
+            y0: num(r.y0),
+            y1: num(r.y1),
+            tmin: num(r.tmin),
+            tmax: num(r.tmax),
+            sides: arr(r.sides).map((s) => num(s)),
+            pieces: arr(r.pieces).map((p) => num(p, -1)),
+        };
+    });
+}
+/** Door-like openings the kernel found (inserts reaching the floor, 1.8 m
+ *  or taller): world boxes. */
+export function parseDoors(raw) {
+    return arr(obj(raw).doors).filter(Array.isArray).map((d) => makeBox(vec(d[0]), vec(d[1])));
+}
+export function parseEdgeFlags(raw) {
+    return arr(obj(raw).flags).filter(Array.isArray).map((f) => ({
+        owner: num(f[0], -1),
+        cls: String(f[1] ?? ""),
+        len: num(f[2]),
+        n: num(f[3]),
+        c: vec(f[4]),
+        box: makeBox(vec(f[5]), vec(f[6])),
+        step: num(f[7]),
+        counts: { gap: num(f[8]), seam: num(f[9]), bridge: num(f[10]), sky: num(f[11]), far: num(f[12]) },
+        eye: vec(f[13]),
+        hit: num(f[14], -1),
+    }));
+}
+export function parseFixtureEnds(raw) {
+    return arr(obj(raw).ends).filter(Array.isArray).map((e) => ({ i: num(e[0], -1), c: vec(e[1]), out: vec(e[2]), r: num(e[3]), eye: vec(e[4]) }));
+}
+export function parseDepthFlags(raw) {
+    return arr(obj(raw).flags).filter(Array.isArray).map((f) => ({
+        kind: String(f[0] ?? ""),
+        line: num(f[1], -1),
+        side: num(f[2], 1),
+        s0: num(f[3]),
+        s1: num(f[4]),
+        y0: num(f[5]),
+        y1: num(f[6]),
+        rows: num(f[7], 1),
+        depth: num(f[8]),
+        c: vec(f[9]),
+    }));
+}
+// ---------------------------------------------------------------------------
+// Geometry helpers
+// ---------------------------------------------------------------------------
+export function instBox(r) {
+    return makeBox(sub(r.c, scale(r.e, 0.5)), add(r.c, scale(r.e, 0.5)));
+}
+/** The world box a depth_step run covers (its rows, 10 cm deep at the facade). */
+export function depthBox(f, lines) {
+    const ln = lines[f.line];
+    const ax = ln?.ax ?? 0;
+    const th = 2 - ax;
+    const lo = [f.c[0], f.y0 - 0.05, f.c[2]];
+    const hi = [f.c[0], f.y1 + 0.05, f.c[2]];
+    lo[ax] = f.s0;
+    hi[ax] = f.s1;
+    lo[th] = f.c[th] - 0.05;
+    hi[th] = f.c[th] + 0.05;
+    return { lo, hi };
+}
+function lookDirs(dir, clear) {
+    return [{ dir: normalize(add(normalize(dir), [0, 0.35, 0])), clear, pref: 1 }];
+}
+function nearestLinePiece(line, p, inst) {
+    if (!line)
+        return undefined;
+    let best;
+    let bd = Infinity;
+    for (const pi of line.pieces) {
+        const r = inst[pi];
+        if (!r)
+            continue;
+        const d = boxDistance(instBox(r), makeBox(p, p));
+        if (d < bd) {
+            bd = d;
+            best = r;
+        }
+    }
+    return best;
+}
+const C_WHY = {
+    seam: (f) => `a ${cm(f.s1 - f.s0)} recess runs up the facade over ${f.rows} row(s): a seam between modules`,
+    hole: (f) => (f.depth >= 2 ? `a ${r2(f.s1 - f.s0)} m wide opening with nothing within 1.2 m behind it, over ${f.rows} rows, the facade on both sides or above it: a hole or a missing module` : `a ${r2(f.s1 - f.s0)} m wide recess ${r2(f.depth)} m deep over ${f.rows} rows: a hole or a missing module`),
+    proud: (f) => `a ${r2(f.s1 - f.s0)} m run stands ${cm(-f.depth)} proud of the facade over ${f.rows} rows: a module out of line`,
+    band_recess: (f) => `the band level recesses ${cm(f.depth)} over ${cm(f.s1 - f.s0)}, flush both sides: a gap in the band`,
+    band_end_recess: (f) => `the band level recesses ${cm(f.depth)} over ${cm(f.s1 - f.s0)} at a band end`,
+    band_missing_run: (f) => `the band level recesses ${cm(f.depth)} over ${r2(f.s1 - f.s0)} m: a missing band run`,
+    band_through: (f) => `the band level opens ${r2(f.depth)} m deep over ${cm(f.s1 - f.s0)}: through the band`,
+};
+/**
+ * exposed_edge, open_fixture_end and depth_step issues,
+ * with confirmation folded in. `holes` (the through_hole issues) are
+ * updated in place when a depth_step hole confirms one.
+ */
+export function judgeGaps(result, inst, want, holes = []) {
+    const out = [];
+    const notes = [];
+    const unmeasured = [];
+    const gk = obj(result.gk);
+    const lines = parseGkLines(gk);
+    const eyes = num(gk.eyes);
+    const ran = (c) => want.has(c) && result[c === "exposed_edge" ? "exposed" : c === "open_fixture_end" ? "fixture_ends" : "depth_steps"] !== undefined;
+    if (eyes <= 0 && (ran("exposed_edge") || ran("open_fixture_end") || ran("depth_step"))) {
+        notes.push("gap detectors: no walkable eye points (no open-sky floor), so nothing counts as seen; exposed_edge, open_fixture_end and depth_step measured nothing.");
+        for (const c of ["exposed_edge", "open_fixture_end", "depth_step"])
+            if (ran(c))
+                unmeasured.push(c);
+    }
+    // Band pieces: the kernel's geometric bands (a run of thin pieces at one
+    // height along a facade wall).
+    const isBand = (r) => r?.r === "struct" && r.w === "band";
+    const edges = ran("exposed_edge") ? parseEdgeFlags(result.exposed).filter((f) => EDGE_CLASSES.has(f.cls) && inst[f.owner]) : [];
+    const depth = ran("depth_step") ? parseDepthFlags(result.depth_steps).filter((f) => lines[f.line]) : [];
+    const depthBoxes = depth.map((f) => depthBox(f, lines));
+    const usedDepth = new Set();
+    if (ran("exposed_edge")) {
+        edges.forEach((e) => {
+            const r = inst[e.owner];
+            const cK = depthBoxes.map((b, j) => (!usedDepth.has(j) && boxDistance(b, e.box) <= CONFIRM_RADIUS ? j : -1)).filter((j) => j >= 0);
+            const band = isBand(r);
+            cK.forEach((j) => usedDepth.add(j));
+            const severity = band || cK.length ? "warn" : "look";
+            const reveal = e.cls === "seam" ? "a coplanar sheet continues within 4 cm: a seam you can see into" : e.cls === "bridge" ? "the next coplanar sheet starts within 35 cm: a gap between sheets" : `the reveal behind it is ${cm(e.step)} deep`;
+            const behind = inst[e.hit];
+            out.push({
+                check: "exposed_edge",
+                severity,
+                path: r.p,
+                pos: v2(e.c),
+                why: `open ${band ? "band" : "outline"} edge ${cm(e.len)} long that nothing covers within 7 mm, seen from walkable space; ${reveal}${cK.length ? "; depth_step confirms it" : ""}`,
+                ev: { cls: e.cls, len_m: r2(e.len), samples: e.n, ...(e.cls === "gap" ? { reveal_m: r3(e.step) } : {}), piece: r.k, seen_from: v2(e.eye), ...(behind && behind !== r ? { behind: behind.p } : {}), ...(cK.length ? { confirmed_by: ["depth_step"] } : {}) },
+                next: `summer_zoom at ${fmt(e.c)}; summer_measure ${r.p} against its neighbour, then move it flush, add the missing piece or cover the end`,
+                score: e.len + (band ? 0.5 : 0),
+                frame: { focus: e.c, size: Math.max(0.8, Math.min(4, e.len)), dirs: [{ dir: normalize(sub(e.eye, e.c)), clear: distance(e.eye, e.c), pref: 1 }] },
+            });
+        });
+    }
+    if (ran("open_fixture_end")) {
+        for (const f of parseFixtureEnds(result.fixture_ends)) {
+            const r = inst[f.i];
+            if (!r)
+                continue;
+            out.push({
+                check: "open_fixture_end",
+                severity: "warn",
+                path: r.p,
+                pos: v2(f.c),
+                why: `open end of ${r.k} (${cm(2 * f.r)} across) seen from walkable space: nothing joins it within 2.5 cm (a missing elbow, coupler, section or end piece)`,
+                ev: { radius_m: r3(f.r), opens: v2(f.out), seen_from: v2(f.eye) },
+                next: `summer_zoom at ${fmt(f.c)}; add the next piece (summer_connect_ports ${r.p} ...), or end the run in the wall or with an end piece`,
+                score: f.r,
+                frame: { focus: f.c, size: Math.max(0.6, 4 * f.r), dirs: [{ dir: normalize(sub(f.eye, f.c)), clear: distance(f.eye, f.c), pref: 1 }] },
+            });
+        }
+    }
+    // depth_step: holes confirm through_hole; the rest are look items. A run
+    // that a door-like opening (an insert reaching the floor) covers over half
+    // its length is the door's recess, not a band running through it.
+    if (ran("depth_step")) {
+        const doors = parseDoors(gk);
+        depth.forEach((f, k) => {
+            if (usedDepth.has(k))
+                return;
+            const box = depthBoxes[k];
+            const ax = lines[f.line]?.ax ?? 0;
+            const run = growBox(box, 0.3);
+            if (doors.some((d) => {
+                const inter = boxIntersection(d, run);
+                return !!inter && inter.hi[ax] - inter.lo[ax] >= 0.5 * (f.s1 - f.s0);
+            }))
+                return;
+            if (f.kind === "hole") {
+                const hole = holes.find((h) => h.check === "through_hole" && boxDistance(growBox(makeBox(h.pos, h.pos), Math.max(num(h.ev.w), num(h.ev.h), 0.3) / 2), box) <= 1.0);
+                if (hole) {
+                    hole.ev.confirmed_by = ["depth_step"];
+                    if (hole.severity === "warn")
+                        hole.severity = "error";
+                    hole.why += `; depth_step confirms a ${r2(f.s1 - f.s0)} m recess`;
+                    return;
+                }
+            }
+            const ln = lines[f.line];
+            const r = nearestLinePiece(ln, boxCenter(box), inst);
+            if (!r)
+                return;
+            const side = [0, 0, 0];
+            side[2 - (ln?.ax ?? 0)] = f.side;
+            out.push({
+                check: "depth_step",
+                severity: "look",
+                path: r.p,
+                pos: v2(boxCenter(box)),
+                why: (C_WHY[f.kind] ?? ((x) => `a depth step (${x.kind}) of ${cm(x.depth)}`))(f),
+                ev: { kind: f.kind, w_m: r2(f.s1 - f.s0), ...(f.depth >= 2 ? { open: true } : { depth_m: r3(f.depth) }), rows: f.rows, y: [r2(f.y0), r2(f.y1)] },
+                next: `summer_zoom at ${fmt(boxCenter(box))}`,
+                score: (f.s1 - f.s0) * Math.abs(f.depth),
+                frame: { focus: boxCenter(box), size: Math.max(1, f.s1 - f.s0), dirs: lookDirs(side, 3) },
+            });
+        });
+    }
+    return { issues: out, unmeasured, notes };
+}

package/dist/core/capabilities/audit/judge.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Judgment for summer_scene_audit: the kernel's raw measurements (rays that
+ * passed, gaps under props, hull overlaps, UV candidates, ...)
+ * become issues with a check, a severity, a node path, a world position, a
+ * one-line reason, the evidence numbers and the next tool to use.
+ *
+ * Every issue is a flag for the agent to LOOK at, never an auto-fix. The
+ * thresholds are the spec's (2 cm floating, 3 cm embed/overlap, 15 deg
+ * parallelism, UV stretch 8); the severity grading above them is ours and
+ * documented next to each check. Roles (wall, floor, insert, prop, ...) come
+ * from the kernel, which derives them from geometry and engine data only.
+ */
+import { type Vec3 } from "../seeing/math.js";
+import type { AuditCheck, Severity } from "./args.js";
+import { type Basis9 } from "./math.js";
+export interface FrameDir {
+    dir: Vec3;
+    clear: number;
+    pref: number;
+}
+export interface FrameHint {
+    focus: Vec3;
+    size: number;
+    dirs: FrameDir[];
+    /** A viewpoint the kernel proved can see the spot (uv_stretch). */
+    viewer?: Vec3;
+}
+export interface AuditIssue {
+    check: AuditCheck;
+    severity: Severity;
+    path: string;
+    pos: Vec3;
+    why: string;
+    ev: Record<string, unknown>;
+    next: string;
+    /** Magnitude for ordering within a severity (bigger first). */
+    score: number;
+    frame?: FrameHint;
+    /** Set by the accept filter: the reason it was accepted (show_accepted). */
+    accepted?: string;
+    /** Set by the accept filter: accepted once, but its evidence changed. */
+    acceptStale?: string;
+}
+export interface InstRow {
+    p: string;
+    k: string;
+    s: string;
+    r: string;
+    in: boolean;
+    o: Vec3;
+    b: Basis9;
+    sc: Vec3;
+    det: number;
+    c: Vec3;
+    e: Vec3;
+    le: Vec3;
+    lc: Vec3;
+    m: number;
+    f: Vec3;
+    nan?: boolean;
+    lo?: Vec3;
+    cl?: number[];
+    /** Why the kernel gave it its role (geometry or material evidence, e.g. "sheet", "slab", "in_opening", "band", "see_through", "size"). */
+    w?: string;
+    /** Its LOCAL transform is identity / its parent's GLOBAL transform is identity. */
+    li?: boolean;
+    pi?: boolean;
+}
+export interface KernelResult {
+    instances?: InstRow[];
+    lines?: unknown[];
+    floors?: Record<string, unknown>;
+    support?: unknown[];
+    overlaps?: unknown[];
+    long_props?: unknown[];
+    uv?: unknown[];
+    /** z_fight from planar face groups: {near, far, pairs, in_mesh}. */
+    zfight_geo?: Record<string, unknown>;
+    lights?: Record<string, unknown>;
+    resources?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/** The 16 clearance directions the kernel measures around every instance
+ *  (8 azimuths at 20 deg up, then 8 at 45 deg up). */
+export declare function clearanceDirections(): Vec3[];
+/** Clusters of see-through rays on each facade line; clusters beside the same
+ *  host and insert (both sides of a too-narrow door) become one issue. */
+export declare function judgeThroughHoles(lines: unknown[], inst: InstRow[]): AuditIssue[];
+/**
+ * floor_gap. Down rays over the tile footprints (a grid, plus rays along the
+ * seams between tiles) and along each tile edge that a wall bounds within
+ * 1 m (the strip between the last tile and the wall base). Each row says
+ * which surface the ray hit FIRST:
+ * - nothing: the void shows (error);
+ * - an underlay with the floor's own surface right under it: the underlay
+ *   plane sits above a drain channel or dip and paints over it ("covers the
+ *   floor", warn), not a hole;
+ * - an underlay with nothing under it: a hole in the tile, or a bare strip
+ *   outside the tiles.
+ * A piece whose own mesh has holes (or whose low surfaces the underlay
+ * covers) in every tile is ONE issue for the piece. Areas are the sum of the
+ * missed rays' own footprints, with the strip's dimensions.
+ */
+export declare function judgeFloorGaps(floors: Record<string, unknown> | undefined, inst: InstRow[]): AuditIssue[];
+export declare function judgeSupport(support: unknown[], inst: InstRow[]): AuditIssue[];
+/** Overlaps the kernel reports start at 1 cm; a prop is an issue when its
+ *  deepest overlap is over 3 cm, and then every partner it cuts is named. */
+export declare const OVERLAP_MIN = 0.03;
+export declare const OVERLAP_PARTNERS = 3;
+export declare function judgeOverlaps(overlaps: unknown[], inst: InstRow[]): AuditIssue[];
+/** World bounds of two pieces touch (within `slack`) on all three axes. */
+export declare function boundsTouch(a: InstRow, b: InstRow, slack?: number): boolean;
+export declare function judgeLongProps(rows: unknown[], inst: InstRow[]): AuditIssue[];
+export declare const UV_STRETCH_LIMIT = 8;
+export declare const UV_MIN_AREA = 0.02;
+/** UVs of a triangle all within this distance sample one texel: a flat
+ *  colour, never a visible stretch. */
+export declare const UV_POINT_EPSILON = 0.002;
+export declare function judgeUv(rows: unknown[], inst: InstRow[]): AuditIssue[];
+export declare function judgeDuplicates(inst: InstRow[]): {
+    issues: AuditIssue[];
+    pairs: Set<string>;
+};
+export declare function judgeZFight(lines: unknown[], floors: Record<string, unknown> | undefined, inst: InstRow[], duplicatePairs: Set<string>, alreadyReported?: ReadonlySet<string>): AuditIssue[];
+/** Which way to nudge a z-fighting face: the plane's normal as a world axis
+ *  and as the piece's own local axis (what summer_set_prop moves). */
+export declare function nudgeAxes(subject: InstRow, normal: Vec3): {
+    world: string;
+    local: string;
+};
+/**
+ * z_fight from geometry: the kernel's planar face groups, compared between
+ * instances (any role: props, roofs, ledges, side walls, ceilings, inserts
+ * against hosts, decals and overlay cards) and within one mesh (two
+ * surfaces on one plane). A pair counts when its plane gap is under twice
+ * the 24-bit depth step at its view distance (the nearest walkable eye
+ * point, camera or bookmark; 30 m without one) for the main camera's near
+ * and far. Severity: warn over 0.05 m2 seen from a viewpoint; look
+ * otherwise, and look (never skipped) when the material says it may be
+ * intentional: render_priority, a depth or normal offset, a see-through
+ * (alpha) material, or no depth test / depth writes.
+ * Returns the issues and the instance pairs they cover (the ray samples do
+ * not report those again).
+ */
+export declare function judgeZFightGeometry(geo: Record<string, unknown> | undefined, inst: InstRow[], duplicatePairs: Set<string>): {
+    issues: AuditIssue[];
+    pairs: Set<string>;
+};
+export declare function judgeLights(lights: Record<string, unknown> | undefined, inst: InstRow[]): AuditIssue[];
+/**
+ * Pieces left at the scene origin, never placed: the global origin within
+ * 1 cm AND an identity LOCAL transform AND an identity parent, and not part
+ * of a structured layout (touching another piece, or one of a row of
+ * siblings along a line through the origin). A module placed so its corner is
+ * the world origin, or one placed by its parent, is not flagged.
+ */
+export declare function unplacedAtOrigin(inst: readonly InstRow[]): Set<InstRow>;
+export declare function judgeTransforms(inst: InstRow[]): AuditIssue[];
+export declare function judgeResources(res: Record<string, unknown> | undefined, inst: InstRow[]): AuditIssue[];
+/** Same check + severity + piece under the same parent: one issue that names
+ *  the count and the range (16 gutter sections 5.4-5.9 cm off the wall). */
+export declare function groupRepeats(issues: AuditIssue[], inst: InstRow[], min?: number): AuditIssue[];