@pascal-app/core 1.0.6 → 1.0.7

package/dist/agent-tools/stairs.js

@@ -58,7 +58,7 @@ export const fitStairTool = {
 export const createStairTool = {
     name: 'create_stair',
     title: 'Create stair',
-    description: "Create a staircase rising from a level, as the editor's stair tool builds one: straight, L (a flight, a landing as deep as the stair is wide, a flight turned 90°) or U (a flight, a landing across, a flight back beside the first). It rises to the level above and owns the floor opening it cuts in every floor it passes; when no level stands above, a blank one is made for it. toLevelId null makes a flight to no level (porch steps, a deck, a raised platform): it rises height, cuts nothing and makes no level. Refused with a code: a flight to or from a declared roof level, and a toLevelId that is not above the level it rises from.\n\nGEOMETRY (get this wrong and the stair pokes through a wall):\n- (x, z) is the middle of the bottom riser, where the flight starts. The first flight runs from there along the climb: at rotation 0 it covers x − width/2 .. x + width/2 and z .. z + its run.\n- rotation in degrees about Y: 0 climbs toward +Z, 90 → +X, 180 → −Z, 270 → −X. Point the climb into the room, away from the wall the bottom step sits against.\n- An L or U turns to the climber's left or right (turn). The result gives the whole footprint and the point the top step arrives at.\n- Keep 0.9 m clear at the foot and at the head of the flight, and the whole footprint inside one room on both levels (a hall is typical): read the room's outline first (get_zones).\n\nOPENINGS: by default the stair owns the opening over its flights and keeps it as the stair moves (openingOffset widens it). An opening of another size, centre or turn, through a slab or ceiling you name, or through one of the two only, is cut as an opening the stair owns, as given.",
+    description: "Create a straight, L or U staircase rising from a level, as the editor's stair tool builds one, and return its id, its footprint and where the top step arrives. An L is a flight, a landing as deep as the stair is wide and a flight turned 90°; a U is a flight, a landing across and a flight back beside the first. It rises to the level above and owns the floor opening it cuts in every floor it passes; when no level stands above, a blank one is made for it. toLevelId null makes a flight to no level (porch steps, a deck, a raised platform): it rises height, cuts nothing and makes no level. Refused with a code: a flight to or from a declared roof level, and a toLevelId that is not above the level it rises from.\n\nGEOMETRY (get this wrong and the stair pokes through a wall):\n- (x, z) is the middle of the bottom riser, where the flight starts. The first flight runs from there along the climb: at rotation 0 it covers x − width/2 .. x + width/2 and z .. z + its run.\n- rotation in degrees about Y: 0 climbs toward +Z, 90 → +X, 180 → −Z, 270 → −X. Point the climb into the room, away from the wall the bottom step sits against.\n- An L or U turns to the climber's left or right (turn). The result gives the whole footprint and the point the top step arrives at.\n- Keep 0.9 m clear at the foot and at the head of the flight, and the whole footprint inside one room on both levels (a hall is typical): read the room's outline first (get_zones).\n\nOPENINGS: by default the stair owns the opening over its flights and keeps it as the stair moves (openingOffset widens it). An opening of another size, centre or turn, through a slab or ceiling you name, or through one of the two only, is cut as an opening the stair owns, as given.",
     input: {
         x: z.number().describe('X of the middle of the bottom riser.'),
         z: z.number().describe('Z of the middle of the bottom riser.'),

package/dist/agent-tools/units.d.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+export declare const unitKind: z.ZodEnum<{
+    apartment: "apartment";
+    commercial: "commercial";
+    common: "common";
+    "hotel-room": "hotel-room";
+}>;
+export declare const createUnitTool: {
+    readonly name: 'create_unit';
+    readonly title: 'Create unit';
+    readonly description: "A unit is one dwelling, suite or tenancy of a building that holds several (an apartment, a condo, a hotel room, a shop): a named group of rooms (zones) under the building. Its members may span levels (a duplex). A zone belongs to at most one unit; a zone in no unit is common area (a corridor, a lobby, the stairs). A single-family house has no units. Create one in a building, named as a person would (Apartment 2B, Suite 301, Shop 1), with the rooms it holds; add or change them later with set_unit_members.";
+    readonly input: {
+        readonly buildingId: z.ZodOptional<z.ZodString>;
+        readonly name: z.ZodString;
+        readonly kind: z.ZodOptional<z.ZodEnum<{
+            apartment: "apartment";
+            commercial: "commercial";
+            common: "common";
+            "hotel-room": "hotel-room";
+        }>>;
+        readonly color: z.ZodOptional<z.ZodString>;
+        readonly memberZoneIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        readonly move: z.ZodOptional<z.ZodBoolean>;
+    };
+};
+export declare const setUnitMembersTool: {
+    readonly name: 'set_unit_members';
+    readonly title: 'Set unit members';
+    readonly description: "A unit is one dwelling, suite or tenancy of a building that holds several (an apartment, a condo, a hotel room, a shop): a named group of rooms (zones) under the building. Its members may span levels (a duplex). A zone belongs to at most one unit; a zone in no unit is common area (a corridor, a lobby, the stairs). A single-family house has no units. Replace the rooms a unit holds with this list: a zone left out leaves the unit and becomes common area, an empty list empties it. Every zone must be on a level of the unit's building.";
+    readonly input: {
+        readonly unitId: z.ZodString;
+        readonly memberZoneIds: z.ZodArray<z.ZodString>;
+        readonly move: z.ZodOptional<z.ZodBoolean>;
+    };
+};
+export declare const listUnitsTool: {
+    readonly name: 'list_units';
+    readonly title: 'List units';
+    readonly description: "A unit is one dwelling, suite or tenancy of a building that holds several (an apartment, a condo, a hotel room, a shop): a named group of rooms (zones) under the building. Its members may span levels (a duplex). A zone belongs to at most one unit; a zone in no unit is common area (a corridor, a lobby, the stairs). A single-family house has no units. List the units of a building, or of every building: id, name, kind, colour, member zone ids and a report (member count, the levels it spans, gross area, each member with its name, level and area).";
+    readonly input: {
+        readonly buildingId: z.ZodOptional<z.ZodString>;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+    };
+};
+export declare const UNIT_TOOL_CONTRACTS: readonly [{
+    readonly name: 'create_unit';
+    readonly title: 'Create unit';
+    readonly description: "A unit is one dwelling, suite or tenancy of a building that holds several (an apartment, a condo, a hotel room, a shop): a named group of rooms (zones) under the building. Its members may span levels (a duplex). A zone belongs to at most one unit; a zone in no unit is common area (a corridor, a lobby, the stairs). A single-family house has no units. Create one in a building, named as a person would (Apartment 2B, Suite 301, Shop 1), with the rooms it holds; add or change them later with set_unit_members.";
+    readonly input: {
+        readonly buildingId: z.ZodOptional<z.ZodString>;
+        readonly name: z.ZodString;
+        readonly kind: z.ZodOptional<z.ZodEnum<{
+            apartment: "apartment";
+            commercial: "commercial";
+            common: "common";
+            "hotel-room": "hotel-room";
+        }>>;
+        readonly color: z.ZodOptional<z.ZodString>;
+        readonly memberZoneIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        readonly move: z.ZodOptional<z.ZodBoolean>;
+    };
+}, {
+    readonly name: 'set_unit_members';
+    readonly title: 'Set unit members';
+    readonly description: "A unit is one dwelling, suite or tenancy of a building that holds several (an apartment, a condo, a hotel room, a shop): a named group of rooms (zones) under the building. Its members may span levels (a duplex). A zone belongs to at most one unit; a zone in no unit is common area (a corridor, a lobby, the stairs). A single-family house has no units. Replace the rooms a unit holds with this list: a zone left out leaves the unit and becomes common area, an empty list empties it. Every zone must be on a level of the unit's building.";
+    readonly input: {
+        readonly unitId: z.ZodString;
+        readonly memberZoneIds: z.ZodArray<z.ZodString>;
+        readonly move: z.ZodOptional<z.ZodBoolean>;
+    };
+}, {
+    readonly name: 'list_units';
+    readonly title: 'List units';
+    readonly description: "A unit is one dwelling, suite or tenancy of a building that holds several (an apartment, a condo, a hotel room, a shop): a named group of rooms (zones) under the building. Its members may span levels (a duplex). A zone belongs to at most one unit; a zone in no unit is common area (a corridor, a lobby, the stairs). A single-family house has no units. List the units of a building, or of every building: id, name, kind, colour, member zone ids and a report (member count, the levels it spans, gross area, each member with its name, level and area).";
+    readonly input: {
+        readonly buildingId: z.ZodOptional<z.ZodString>;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+    };
+}];
+//# sourceMappingURL=units.d.ts.map

package/dist/agent-tools/units.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"units.d.ts","sourceRoot":"","sources":["../../src/agent-tools/units.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,QAAQ;;;;;EAIlB,CAAA;AAqBH,eAAO,MAAM,cAAc;mBACnB,aAAa;oBACZ,aAAa;;;;;;;;;;;;;;;CAiBgB,CAAA;AAEtC,eAAO,MAAM,kBAAkB;mBACvB,kBAAkB;oBACjB,kBAAkB;;;;;;;CAOW,CAAA;AAEtC,eAAO,MAAM,aAAa;mBAClB,YAAY;oBACX,YAAY;;;;;;iBAGJ,YAAY;;CACS,CAAA;AAEtC,eAAO,MAAM,mBAAmB;mBAvCxB,aAAa;oBACZ,aAAa;;;;;;;;;;;;;;;;mBAoBd,kBAAkB;oBACjB,kBAAkB;;;;;;;;mBAUnB,YAAY;oBACX,YAAY;;;;;;iBAGJ,YAAY;;EAGkE,CAAA"}

package/dist/agent-tools/units.js

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { NodeId } from './node-id.js';
+// The schema's UNIT_KINDS, spelled here: a contract imports zod and dependency-free files only
+// (contracts-purity.test.ts), and the operation parses the node with the schema itself.
+export const unitKind = z
+    .enum(['apartment', 'hotel-room', 'commercial', 'common'])
+    .describe('What the unit is: apartment (a dwelling: a flat, a condo, one side of a duplex), hotel-room (a suite or guest room), commercial (a shop, an office, a lot let on its own), common (shared space grouped on purpose). Default apartment.');
+const WHAT_A_UNIT_IS = 'A unit is one dwelling, suite or tenancy of a building that holds several (an apartment, a condo, a hotel room, a shop): a named group of rooms (zones) under the building. Its members may span levels (a duplex). A zone belongs to at most one unit; a zone in no unit is common area (a corridor, a lobby, the stairs). A single-family house has no units.';
+const buildingId = NodeId.optional().describe("The building. Default: the building of the floor the person is viewing, else the scene's only building.");
+const memberZoneIds = (what) => z
+    .array(NodeId)
+    .describe(`${what}, by zone ids from get_zones or create_room, on any level of the building. A zone already in another unit is refused (zone_in_other_unit, naming that unit) unless move is true.`);
+const move = z
+    .boolean()
+    .optional()
+    .describe('true: a zone already in another unit leaves that unit for this one.');
+export const createUnitTool = {
+    name: 'create_unit',
+    title: 'Create unit',
+    description: `${WHAT_A_UNIT_IS} Create one in a building, named as a person would (Apartment 2B, Suite 301, Shop 1), with the rooms it holds; add or change them later with set_unit_members.`,
+    input: {
+        buildingId,
+        name: z
+            .string()
+            .min(1)
+            .max(120)
+            .describe('The unit as a person names it: Apartment 2B, Suite 301, Shop 1.'),
+        kind: unitKind.optional(),
+        color: z
+            .string()
+            .optional()
+            .describe('#rrggbb tint of the unit in the plan (default Pascal’s).'),
+        memberZoneIds: memberZoneIds('The rooms the unit holds').optional(),
+        move,
+    },
+};
+export const setUnitMembersTool = {
+    name: 'set_unit_members',
+    title: 'Set unit members',
+    description: `${WHAT_A_UNIT_IS} Replace the rooms a unit holds with this list: a zone left out leaves the unit and becomes common area, an empty list empties it. Every zone must be on a level of the unit's building.`,
+    input: {
+        unitId: NodeId.describe('The unit, by an id from create_unit or list_units.'),
+        memberZoneIds: memberZoneIds('The rooms the unit holds from now on'),
+        move,
+    },
+};
+export const listUnitsTool = {
+    name: 'list_units',
+    title: 'List units',
+    description: `${WHAT_A_UNIT_IS} List the units of a building, or of every building: id, name, kind, colour, member zone ids and a report (member count, the levels it spans, gross area, each member with its name, level and area).`,
+    input: { buildingId },
+    annotations: { readOnlyHint: true },
+};
+export const UNIT_TOOL_CONTRACTS = [createUnitTool, setUnitMembersTool, listUnitsTool];

package/dist/agent-tools/verify-scene-usage.d.ts

@@ -0,0 +1,44 @@
+/**
+ * How `verify_scene` shows the usage findings to a model: a room's missing turning circle and
+ * pocket as one entry for the room, a narrow place as one entry for the rooms it leads to, every
+ * other finding whole but without the structure its message and node ids already carry, and the
+ * words every entry would repeat once. The report keeps each finding as measured (`usageIssues`);
+ * `type` and `room` give them back.
+ */
+/** The findings a room's one entry holds. */
+export declare const ROOM_FOLDED_TYPES: readonly ['usage_turning_narrow', 'usage_pocket'];
+/** The type of a narrow passage's finding: one for each place, naming the rooms it leads to. */
+export declare const PASSAGE_TYPE = "usage_passage_narrow";
+/** The type of a room's one entry; asking for it returns the findings it holds. */
+export declare const ROOM_ENTRY_TYPE = "usage_room";
+export declare const isUsageType: (type: unknown) => type is string;
+export declare const isRoomFolded: (type: unknown) => boolean;
+type Found = Record<string, unknown>;
+/** The ids of the rooms a narrow passage leads to. */
+export declare const servedRoomIds: (passages: Found[]) => Set<string>;
+/** The entrances the passages were measured from: said once in the note when there is one, by each entry when there are several. */
+export declare const passageEntrances: (passages: Found[]) => string[];
+/**
+ * One entry per room for its turning circle and pocket findings, in the order the rooms first
+ * appear. A pocket that is the room's whole free floor, in a room a narrow passage leads to, says
+ * what the passage says (a path under a 0.60 m unit leads nowhere a unit can leave), so the entry
+ * does not say it twice and a room with nothing else has none; `count` is every finding it holds.
+ */
+export declare function foldUsageRooms(members: Found[], served: ReadonlySet<string>): Found[];
+/**
+ * A usage finding without what its message and node ids already say (obstacles, thresholds, code
+ * table row). A narrow place keeps its sentence and the things that bound it: the figure and the
+ * rooms are in the sentence, and a room's own findings are asked for by its name.
+ */
+export declare function slimUsageFinding(found: Found, entrances?: readonly string[]): Found;
+/** Findings placed in, serving or naming a room or one of its contents, returned whole. */
+export declare function findingsOfRoom(issues: unknown[], room: string, scope: unknown): Found[];
+/** The rooms that have usage findings, for the answer to a room nothing was found for. */
+export declare function roomsWithUsageFindings(issues: unknown[]): string[];
+/**
+ * The words every usage entry would repeat, said once: what a finding is, the thresholds it reads
+ * against (the numbers the checks apply; a test holds them to those), and what the entries are.
+ */
+export declare function usageNote(measuredFrom?: readonly string[]): string;
+export {};
+//# sourceMappingURL=verify-scene-usage.d.ts.map

package/dist/agent-tools/verify-scene-usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-scene-usage.d.ts","sourceRoot":"","sources":["../../src/agent-tools/verify-scene-usage.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,6CAA6C;AAC7C,eAAO,MAAM,iBAAiB,YAAI,sBAAsB,EAAE,cAAc,CAAU,CAAA;AAElF,gGAAgG;AAChG,eAAO,MAAM,YAAY,yBAAyB,CAAA;AAElD,mFAAmF;AACnF,eAAO,MAAM,eAAe,eAAe,CAAA;AAE3C,eAAO,MAAM,WAAW,SAAU,OAAO,KAAG,IAAI,IAAI,MACG,CAAA;AAEvD,eAAO,MAAM,YAAY,SAAU,OAAO,KAAG,OACa,CAAA;AAE1D,KAAK,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAgCpC,sDAAsD;AACtD,eAAO,MAAM,aAAa,aAAc,KAAK,EAAE,gBACmC,CAAA;AAElF,oIAAoI;AACpI,eAAO,MAAM,gBAAgB,aAAc,KAAK,EAAE,KAAG,MAAM,EAI1D,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,KAAK,EAAE,CA2BrF;AAKD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,GAAE,SAAS,MAAM,EAAO,GAAG,KAAK,CAkBvF;AAOD,2FAA2F;AAC3F,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,EAAE,CAyBvF;AAED,0FAA0F;AAC1F,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,EAAE,CAQlE;AAID;;;GAGG;AACH,wBAAgB,SAAS,CAAC,YAAY,GAAE,SAAS,MAAM,EAAO,GAAG,MAAM,CAYtE"}

package/dist/agent-tools/verify-scene-usage.js

@@ -0,0 +1,146 @@
+import { USAGE_INDICATORS } from '../building/code-profile.js';
+/**
+ * How `verify_scene` shows the usage findings to a model: a room's missing turning circle and
+ * pocket as one entry for the room, a narrow place as one entry for the rooms it leads to, every
+ * other finding whole but without the structure its message and node ids already carry, and the
+ * words every entry would repeat once. The report keeps each finding as measured (`usageIssues`);
+ * `type` and `room` give them back.
+ */
+/** The findings a room's one entry holds. */
+export const ROOM_FOLDED_TYPES = ['usage_turning_narrow', 'usage_pocket'];
+/** The type of a narrow passage's finding: one for each place, naming the rooms it leads to. */
+export const PASSAGE_TYPE = 'usage_passage_narrow';
+/** The type of a room's one entry; asking for it returns the findings it holds. */
+export const ROOM_ENTRY_TYPE = 'usage_room';
+export const isUsageType = (type) => typeof type === 'string' && type.startsWith('usage_');
+export const isRoomFolded = (type) => ROOM_FOLDED_TYPES.includes(type);
+const isRecord = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const placeOf = (found) => (isRecord(found.place) ? found.place : {});
+const roomIdOf = (found) => String(placeOf(found).roomId ?? '');
+const stringsOf = (value) => Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+const round2 = (value) => Math.round(value * 100) / 100;
+/** A finding's place on the plan to the centimetre, or nothing. */
+function atOf(found) {
+    const at = placeOf(found).at;
+    return Array.isArray(at) && typeof at[0] === 'number' && typeof at[1] === 'number'
+        ? [round2(at[0]), round2(at[1])]
+        : undefined;
+}
+/** The rooms a narrow passage leads to: its `serves`. */
+function servedBy(found) {
+    return Array.isArray(found.serves)
+        ? found.serves.filter(isRecord).map((room) => ({
+            room: String(room.room ?? ''),
+            roomId: String(room.roomId ?? ''),
+        }))
+        : [];
+}
+/** The ids of the rooms a narrow passage leads to. */
+export const servedRoomIds = (passages) => new Set(passages.flatMap((found) => servedBy(found).map((room) => room.roomId)));
+/** The entrances the passages were measured from: said once in the note when there is one, by each entry when there are several. */
+export const passageEntrances = (passages) => [
+    ...new Set(passages.flatMap((found) => (typeof found.fromDoor === 'string' ? [found.fromDoor] : []))),
+];
+/**
+ * One entry per room for its turning circle and pocket findings, in the order the rooms first
+ * appear. A pocket that is the room's whole free floor, in a room a narrow passage leads to, says
+ * what the passage says (a path under a 0.60 m unit leads nowhere a unit can leave), so the entry
+ * does not say it twice and a room with nothing else has none; `count` is every finding it holds.
+ */
+export function foldUsageRooms(members, served) {
+    const rooms = new Map();
+    for (const found of members) {
+        const key = roomIdOf(found);
+        rooms.set(key, [...(rooms.get(key) ?? []), found]);
+    }
+    return [...rooms.entries()].flatMap(([roomId, held]) => {
+        const clauses = held
+            .filter((found) => !(found.type === 'usage_pocket' && found.wholeRoom === true && served.has(roomId)))
+            .map((found) => String(found.brief ?? found.message));
+        if (!clauses.length)
+            return [];
+        const warning = held.some((found) => found.severity !== 'info');
+        const first = held[0];
+        return [
+            {
+                type: ROOM_ENTRY_TYPE,
+                severity: warning ? 'warning' : 'info',
+                message: `${String(placeOf(first).room ?? '')}: ${clauses.join('; ')}.`,
+                nodeIds: [...new Set(held.flatMap((found) => stringsOf(found.nodeIds)))],
+                count: held.length,
+                ...(held.some((found) => found.approximate === true) ? { approximate: true } : {}),
+            },
+        ];
+    });
+}
+/** What an entry for one finding keeps: its sentence, its nodes, its measured values and where. */
+const KEPT = ['type', 'severity', 'message', 'nodeIds', 'valueM', 'valueM2', 'valueDeg'];
+/**
+ * A usage finding without what its message and node ids already say (obstacles, thresholds, code
+ * table row). A narrow place keeps its sentence and the things that bound it: the figure and the
+ * rooms are in the sentence, and a room's own findings are asked for by its name.
+ */
+export function slimUsageFinding(found, entrances = []) {
+    if (found.type === PASSAGE_TYPE) {
+        const rooms = new Set(servedBy(found).map((room) => room.roomId));
+        return {
+            type: found.type,
+            severity: found.severity,
+            message: entrances.length < 2 && typeof found.brief === 'string' ? found.brief : found.message,
+            nodeIds: stringsOf(found.nodeIds).filter((id) => !rooms.has(id)),
+            ...(found.approximate === true ? { approximate: true } : {}),
+        };
+    }
+    const slim = {};
+    for (const key of KEPT)
+        if (found[key] !== undefined)
+            slim[key] = found[key];
+    if (found.approximate === true)
+        slim.approximate = true;
+    const at = atOf(found);
+    if (at)
+        slim.at = at;
+    return slim;
+}
+/** The rooms a usage finding is about: its own, and the rooms a narrow passage leads to. */
+function roomsOf(found) {
+    return [...servedBy(found), { room: String(placeOf(found).room ?? ''), roomId: roomIdOf(found) }];
+}
+/** Findings placed in, serving or naming a room or one of its contents, returned whole. */
+export function findingsOfRoom(issues, room, scope) {
+    const wanted = room.trim().toLowerCase();
+    const rooms = Array.isArray(scope)
+        ? scope.filter((entry) => isRecord(entry) &&
+            [entry.roomId, entry.room].some((name) => typeof name === 'string' && name.trim().toLowerCase() === wanted))
+        : [];
+    const nodeIds = new Set(rooms.flatMap((entry) => stringsOf(entry.nodeIds)));
+    return issues.filter((issue) => isRecord(issue) &&
+        (roomsOf(issue).some((found) => found.roomId.toLowerCase() === wanted || found.room.trim().toLowerCase() === wanted) ||
+            Object.entries(issue).some(([key, value]) => key.endsWith('Ids')
+                ? stringsOf(value).some((id) => nodeIds.has(id))
+                : key.endsWith('Id') && typeof value === 'string' && nodeIds.has(value))));
+}
+/** The rooms that have usage findings, for the answer to a room nothing was found for. */
+export function roomsWithUsageFindings(issues) {
+    return [
+        ...new Set(issues.flatMap((issue) => isRecord(issue) && isUsageType(issue.type) ? roomsOf(issue).map((room) => room.room) : [])),
+    ].filter(Boolean);
+}
+const metres = (value) => value.toFixed(2);
+/**
+ * The words every usage entry would repeat, said once: what a finding is, the thresholds it reads
+ * against (the numbers the checks apply; a test holds them to those), and what the entries are.
+ */
+export function usageNote(measuredFrom = []) {
+    const { passage, doorClear, turning } = USAGE_INDICATORS;
+    return [
+        'Usage findings are indicators read from the drawn scene, not code checks; a figure from a code names it.',
+        `A passage is narrow under ${metres(passage.value)} m (${metres(doorClear.value)} m through a doorway), a turning circle under ${metres(turning.value)} m; a pocket is floor a 0.60 m unit fits on and cannot leave.`,
+        'A piece 2 cm into another is a contact, 8 cm a warning; a window is blocked by a piece within 15 cm of the glass and over 30 cm above its sill; a door stopping before 80° is a finding; a bed wants 0.60 m at a side and at the foot. Use defects warn even on approximate shapes.',
+        ...(measuredFrom.length
+            ? [`Ground-floor passages are measured from “${measuredFrom[0]}”.`]
+            : []),
+        'A doorway is read between its jambs, and the limit applies to that clear width, not the door as drawn.',
+        'A narrow passage is one entry for the place, naming the rooms it leads to; a slot or cupboard on no way to a room has none, a pocket speaks for dead floor. One usage_room entry per room holds its turning circle and pocket.',
+    ].join(' ');
+}

package/dist/agent-tools/verify-scene.d.ts

@@ -1,4 +1,4 @@
-import type { z } from 'zod';
+import { z } from 'zod';
 /** Adds inputs and a sentence of description to verify_scene, for a check registered with it. */
 export declare function extendVerifyScene(extension: {
     input: Record<string, z.ZodType>;
@@ -10,4 +10,15 @@ export declare const verifySceneTool: {
     readonly description: string;
     readonly input: Record<string, z.ZodType>;
 };
+/**
+ * What the model reads for `verify_scene`: the same facts, grouped. Every warning and error is
+ * whole — its message, its node ids and its measurements — a repeated informational finding is one
+ * entry per type with a few examples and the call that returns them all, The usage findings are the exception that
+ * keeps every finding: a narrow passage is one entry for its place, a room's turning circle and
+ * pocket are one entry for the room, the others arrive one by one without the structure their sentence repeats (`verify-scene-usage.ts`).
+ * A `type` or `room` question and a refusal answer as they came; no other argument widens the
+ * answer. The editor, the structured MCP result and the benchmarks keep the report `verify_scene`
+ * returned.
+ */
+export declare function verifySceneModelResult(output: unknown, input: unknown): unknown;
 //# sourceMappingURL=verify-scene.d.ts.map

package/dist/agent-tools/verify-scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verify-scene.d.ts","sourceRoot":"","sources":["../../src/agent-tools/verify-scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAS5B,iGAAiG;AACjG,wBAAgB,iBAAiB,CAAC,SAAS,EAAE;IAC3C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAA;IAChC,WAAW,EAAE,MAAM,CAAA;CACpB,QAEA;AAKD,eAAO,MAAM,eAAe;IAC1B,IAAI;IACJ,KAAK;aACD,WAAW;aAGX,KAAK,EAAI,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC;CAGvC,CAAA"}
+{"version":3,"file":"verify-scene.d.ts","sourceRoot":"","sources":["../../src/agent-tools/verify-scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAsBvB,iGAAiG;AACjG,wBAAgB,iBAAiB,CAAC,SAAS,EAAE;IAC3C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAA;IAChC,WAAW,EAAE,MAAM,CAAA;CACpB,QAEA;AAKD,eAAO,MAAM,eAAe;IAC1B,IAAI;IACJ,KAAK;aACD,WAAW;aAQX,KAAK,EAAI,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC;CAqBvC,CAAA;AAsCD;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAY/E"}

package/dist/agent-tools/verify-scene.js

@@ -1,3 +1,5 @@
+import { z } from 'zod';
+import { findingsOfRoom, foldUsageRooms, isRoomFolded, isUsageType, PASSAGE_TYPE, passageEntrances, ROOM_ENTRY_TYPE, roomsWithUsageFindings, servedRoomIds, slimUsageFinding, usageNote, } from './verify-scene-usage.js';
 /**
  * `verify_scene`'s contract. Other modules extend it with an input and a sentence for the check
  * they register (the photo's: `photo`), so it stays one tool agents know, with one contract on
@@ -8,14 +10,192 @@ const extensions = [];
 export function extendVerifyScene(extension) {
     extensions.push(extension);
 }
-const DESCRIPTION = 'Optional whole-scene evidence: per-level content, roles (storey, roof-only, support) and the spaces its walls enclose, then every problem found, each with a type: empty levels, walls with no room or door, a space the walls enclose with no room over it (space_no_room) or with several and no wall between them (space_many_rooms), a room the walls do not close (room_not_enclosed) or with no name (room_unnamed), rooms with no floor or ceiling, storeys with no stair, roof levels misused, walls intersecting a covering slab or ending coplanar with its walking surface (wall_covering_slab_contact, with wallId and slabId), openings off their wall, stairs off their slab or blocked, furniture blocking a door or overlapping, a house past its lot line or in its required yards, every node field its schema rejects (schema_invalid, with its nodeId and path; valid is then false, and the level holding the node lists it as unread and is measured once it is fixed), a node kind no schema here knows, once per kind (schema_unknown_kind, info: a plugin kind), a hidden site (site_hidden). Static authored ceiling objects report transformed bounds extending above their ceiling attachment and bounds overlapping solid covering slab bands, with node IDs and measured metres; stored and derived slab holes are subtracted. Wall-mounted objects report a front oriented toward their host; static authored wall bounds report wall-body overlap and extension through the opposite face. With settled editor meshes, catalog wall bounds and large competing coplanar faces against the host or another item on the same wall are also measured within 1 mm. Hidden back-to-wall contact is not competing face evidence. These are observations, not instructions to change the scene or proof of exact mesh intersection. Bounds are measured in the owning building frame, including stacked level elevations. Unknown catalog raw bounds without meshes, animated models, unsupported attachment frames, unresolved scripted wall cuts, roof collisions, recessed slab shells and foundation volumes are not assessed.';
+const DESCRIPTION = 'Optional whole-scene evidence: per-level content, roles (storey, roof-only, support) and the spaces its walls enclose, then every problem found, each with a type: empty levels, walls with no room or door, a space the walls enclose with no room over it (space_no_room) or with several and no wall between them (space_many_rooms), a room the walls do not close (room_not_enclosed) or with no name (room_unnamed), two rooms on the same clear floor (zones_overlap) and floor inside a covered space that no zone or stair claims (floor_unclaimed), both warnings with their area, width and place and quiet under 0.1 m² (overlap), 0.3 m² (unclaimed) or 15 cm wide, wall bodies not counting as floor, an end that stops 3-25 cm short of another wall (wall_end_short, warning: the daylight in cm, both walls named; an end that touches a wall is a joint) and a wall 0.5-6 degrees off the line of the walls it carries on from or sits between, when that moves its far end 2 cm or more off the line (wall_nearly_aligned, warning: the angle, the offset, the neighbours; a larger turn is an angle drawn on purpose and is not named), rooms with no floor or ceiling, storeys with no stair, roof levels misused, walls intersecting a covering slab or ending coplanar with its walking surface (wall_covering_slab_contact, with wallId and slabId), openings off their wall, stairs off their slab or blocked, furniture blocking a door or overlapping, a house past its lot line or in its required yards, every node field its schema rejects (schema_invalid, with its nodeId and path; valid is then false, and the level holding the node lists it as unread and is measured once it is fixed), a node kind no schema here knows, once per kind (schema_unknown_kind, info: a plugin kind), a hidden site (site_hidden). What the surfaces of a room say, each one an observation to keep when it is intended: a wet room whose walls are not tiled where its fixtures stand (room_wet_untiled), skirting in no room or on part of the wall faces of a room (rooms_no_skirting, rooms_skirting_partial), and floors and wall faces left at the default finish (rooms_floors_default, wall_faces_default). Static authored ceiling objects report transformed bounds extending above their ceiling attachment and bounds overlapping solid covering slab bands, with node IDs and measured metres; stored and derived slab holes are subtracted. Wall-mounted objects report a front oriented toward their host; static authored wall bounds report wall-body overlap and extension through the opposite face. With settled editor meshes, catalog wall bounds and large competing coplanar faces against the host or another item on the same wall are also measured within 1 mm. Hidden back-to-wall contact is not competing face evidence. These are observations, not instructions to change the scene or proof of exact mesh intersection. Bounds are measured in the owning building frame, including stacked level elevations. Unknown catalog raw bounds without meshes, animated models, unsupported attachment frames, unresolved scripted wall cuts, roof collisions, recessed slab shells and foundation volumes are not assessed.';
 export const verifySceneTool = {
     name: 'verify_scene',
     title: 'Verify scene',
     get description() {
-        return [DESCRIPTION, ...extensions.map((extension) => extension.description)].join(' ');
+        return [
+            DESCRIPTION,
+            'Every warning and every error arrives whole, its own measurements with it; a repeated informational finding (severity info) arrives once, with its count, its elements and a few examples.',
+            "Usage findings arrive trimmed, a narrow passage as one entry for the place with the rooms it leads to, each room's turning circle and pocket as one usage_room entry; `room` (a room's id or name) returns its whole findings plus every finding naming its items, doors or windows, even when placed in a neighbouring room; `type` returns the whole findings of that kind.",
+            ...extensions.map((extension) => extension.description),
+        ].join(' ');
     },
     get input() {
-        return Object.assign({}, ...extensions.map((extension) => extension.input));
+        return Object.assign({
+            type: z
+                .string()
+                .min(1)
+                .optional()
+                .describe('One finding type (for example "usage_passage_narrow"): the answer then lists every original finding of that type, whole, and none of the other blocks of the report.'),
+            room: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("A room's id or name: the answer lists its findings whole, including passages serving it and every finding naming its items, doors or windows."),
+        }, ...extensions.map((extension) => extension.input));
     },
 };
+const groupedReport = z.object({
+    issues: z.array(z.unknown()),
+    issueGroups: z.array(z.looseObject({
+        type: z.string(),
+        message: z.string(),
+        count: z.number().int().positive(),
+        issueIndexes: z.array(z.number().int().nonnegative()).min(1),
+        // Read for the presentation alone: a group's other fields (its moves) ride along untouched.
+        severity: z.enum(['info', 'warning']).optional(),
+        nodes: z.unknown().optional(),
+    })),
+});
+/** Complete examples of one repeated informational finding that ride with its group. */
+const GROUP_EXAMPLES = 3;
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+/** `verify_scene`'s arguments, read for the presentation; the operation itself receives them all. */
+function requestedType(input) {
+    const type = isRecord(input) ? input.type : null;
+    return typeof type === 'string' && type.length > 0 ? type : null;
+}
+function requestedRoom(input) {
+    const room = isRecord(input) ? input.room : null;
+    return typeof room === 'string' && room.trim().length > 0 ? room : null;
+}
+/**
+ * What the model reads for `verify_scene`: the same facts, grouped. Every warning and error is
+ * whole — its message, its node ids and its measurements — a repeated informational finding is one
+ * entry per type with a few examples and the call that returns them all, The usage findings are the exception that
+ * keeps every finding: a narrow passage is one entry for its place, a room's turning circle and
+ * pocket are one entry for the room, the others arrive one by one without the structure their sentence repeats (`verify-scene-usage.ts`).
+ * A `type` or `room` question and a refusal answer as they came; no other argument widens the
+ * answer. The editor, the structured MCP result and the benchmarks keep the report `verify_scene`
+ * returned.
+ */
+export function verifySceneModelResult(output, input) {
+    const parsed = groupedReport.safeParse(output);
+    if (!parsed.success)
+        return output;
+    const { issues, issueGroups } = parsed.data;
+    if (issueGroups.some((group) => group.issueIndexes.some((index) => index >= issues.length)))
+        return output;
+    const report = output;
+    const type = requestedType(input);
+    const room = requestedRoom(input);
+    if (type)
+        return oneTypeReport(report, issues, issueGroups, type, room);
+    if (room)
+        return oneRoomReport(report, issues, room);
+    return compactReport(report, issues, issueGroups);
+}
+/**
+ * `type: "…"`: every original finding of that one type, and none of the report's other blocks.
+ * `usage_room`, the type of a room's entry, gives the findings the entries hold; with a `room`, only that room's.
+ */
+function oneTypeReport(report, issues, issueGroups, type, room) {
+    const ofType = issues.filter((issue) => isRecord(issue) &&
+        (type === ROOM_ENTRY_TYPE ? isRoomFolded(issue.type) : issue.type === type));
+    const findings = room ? findingsOfRoom(ofType, room, report.roomScope) : ofType;
+    const named = { ok: report.ok, type, ...(room ? { room } : {}) };
+    if (findings.length > 0)
+        return { ...named, issueCount: findings.length, issues: findings };
+    return {
+        ...named,
+        issueCount: 0,
+        issues: [],
+        types: Object.fromEntries(issueGroups.map((group) => [group.type, group.count])),
+    };
+}
+/** `room: "…"`: the room's findings and those naming its contents, whole. */
+function oneRoomReport(report, issues, room) {
+    const findings = findingsOfRoom(issues, room, report.roomScope);
+    if (findings.length > 0)
+        return { ok: report.ok, room, issueCount: findings.length, issues: findings };
+    return {
+        ok: report.ok,
+        room,
+        issueCount: 0,
+        issues: [],
+        rooms: roomsWithUsageFindings(issues),
+    };
+}
+function compactReport(report, issues, issueGroups) {
+    const { issueGroups: _groups, ...rest } = report;
+    const { shown, measuredFrom } = shownIssues(issues, issueGroups);
+    return {
+        ...rest,
+        issueCount: issues.length,
+        issues: shown,
+        ...(shown.some((issue) => isRecord(issue) && isUsageType(issue.type))
+            ? { usageNote: usageNote(measuredFrom) }
+            : {}),
+    };
+}
+/** Every warning and error whole; one entry for each repeated informational finding; the usage findings as the room entries and the singles they are. */
+function shownIssues(issues, issueGroups) {
+    const shown = [];
+    const grouped = new Set();
+    const roomFindings = [];
+    let roomsAt = -1;
+    const passages = issues.filter(isRecord).filter((issue) => issue.type === PASSAGE_TYPE);
+    const entrances = passageEntrances(passages);
+    for (const group of issueGroups) {
+        const members = group.issueIndexes.map((index) => {
+            grouped.add(index);
+            return issues[index];
+        });
+        // A room's turning circle and pocket are one entry for the room, where the first of them stood.
+        if (isRoomFolded(group.type)) {
+            if (roomsAt < 0)
+                roomsAt = shown.length;
+            roomFindings.push(...members.filter(isRecord));
+            continue;
+        }
+        // The other usage findings arrive one by one, info or not, without the structure their message repeats.
+        if (isUsageType(group.type)) {
+            shown.push(...members.map((member) => isRecord(member) ? slimUsageFinding(member, entrances) : member));
+            continue;
+        }
+        // A lone finding of a type is its own complete example, informational or not.
+        if (group.severity === 'info' && members.length > 1) {
+            shown.push(infoGroup(group, members));
+            continue;
+        }
+        shown.push(...members);
+    }
+    if (roomsAt >= 0) {
+        const entries = foldUsageRooms(roomFindings, servedRoomIds(passages));
+        shown.splice(roomsAt, 0, ...entries.filter((entry) => entry.severity !== 'info'), ...entries.filter((entry) => entry.severity === 'info'));
+    }
+    // A finding no group gathered still arrives whole: the presentation hides none.
+    issues.forEach((issue, index) => {
+        if (!grouped.has(index))
+            shown.push(issue);
+    });
+    return { shown, measuredFrom: entrances.length === 1 ? entrances : [] };
+}
+/** A repeated informational finding: how many, where, a few examples, and how to read them all. */
+function infoGroup(group, members) {
+    const { issueIndexes: _indexes, nodes: _nodes, ...summary } = group;
+    return {
+        ...summary,
+        examples: distinctExamples(members),
+        detail: `verify_scene({ "type": "${group.type}" }) returns all ${members.length} findings`,
+    };
+}
+/** The first few findings that differ, so a group of identical records costs one of them. */
+function distinctExamples(members) {
+    const examples = [];
+    const seen = new Set();
+    for (const member of members) {
+        const key = JSON.stringify(member);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        examples.push(member);
+        if (examples.length === GROUP_EXAMPLES)
+            break;
+    }
+    return examples;
+}

package/dist/agent-tools/view-scene.d.ts

@@ -16,6 +16,9 @@ export declare const viewSceneTool: {
     name: string;
     title: string;
     description: string;
+    surfaceNotes: {
+        mcp: string;
+    };
     input: {
         target: z.ZodOptional<z.ZodString>;
         interior: z.ZodOptional<z.ZodObject<{

package/dist/agent-tools/view-scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"view-scene.d.ts","sourceRoot":"","sources":["../../src/agent-tools/view-scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,kFAAkF;AAClF,eAAO,MAAM,aAAa,YACxB,OAAO,EACP,YAAY,EACZ,MAAM,EACN,YAAY,EACZ,OAAO,EACP,YAAY,EACZ,MAAM,EACN,YAAY,CACJ,CAAA;AAEV;;;;GAIG;AACH,eAAO,MAAM,YAAY,YACvB,QAAQ,EACR,aAAa,EACb,cAAc,EACd,MAAM,EACN,OAAO,EACP,MAAM,EACN,WAAW,EACX,YAAY,CACJ,CAAA;AAEV,eAAO,MAAM,UAAU,2MAAwD,CAAA;AAE/E,+FAA+F;AAC/F,eAAO,MAAM,aAAa,YAAI,SAAS,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAU,CAAA;AAE/F,6FAA6F;AAC7F,eAAO,MAAM,WAAW,OAAO,CAAA;AAE/B,eAAO,MAAM,aAAa;IACxB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,MAAM;QAMN,QAAQ;;;;QASR,YAAY;;;;;;;;QAUZ,IAAI;;;;;;;;;;;;;;;;;;;QAMJ,SAAS;QAMT,SAAS;QAKT,QAAQ;QAGR,GAAG;QAKH,UAAU;;;;QAIV,MAAM;;;;;;QAcN,QAAQ;;;;;;;;QAMR,KAAK;QASL,KAAK;;;;;CAmBR,CAAA"}
+{"version":3,"file":"view-scene.d.ts","sourceRoot":"","sources":["../../src/agent-tools/view-scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,kFAAkF;AAClF,eAAO,MAAM,aAAa,YACxB,OAAO,EACP,YAAY,EACZ,MAAM,EACN,YAAY,EACZ,OAAO,EACP,YAAY,EACZ,MAAM,EACN,YAAY,CACJ,CAAA;AAEV;;;;GAIG;AACH,eAAO,MAAM,YAAY,YACvB,QAAQ,EACR,aAAa,EACb,cAAc,EACd,MAAM,EACN,OAAO,EACP,MAAM,EACN,WAAW,EACX,YAAY,CACJ,CAAA;AAEV,eAAO,MAAM,UAAU,2MAAwD,CAAA;AAE/E,+FAA+F;AAC/F,eAAO,MAAM,aAAa,YAAI,SAAS,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAU,CAAA;AAE/F,6FAA6F;AAC7F,eAAO,MAAM,WAAW,OAAO,CAAA;AAE/B,eAAO,MAAM,aAAa;IACxB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,YAAY;QACV,GAAG;;IAEL,KAAK;QACH,MAAM;QAMN,QAAQ;;;;QASR,YAAY;;;;;;;;QAUZ,IAAI;;;;;;;;;;;;;;;;;;;QAMJ,SAAS;QAMT,SAAS;QAKT,QAAQ;QAGR,GAAG;QAKH,UAAU;;;;QAIV,MAAM;;;;;;QAcN,QAAQ;;;;;;;;QAMR,KAAK;QASL,KAAK;;;;;CAmBR,CAAA"}

package/dist/agent-tools/view-scene.js

@@ -35,7 +35,10 @@ export const VIEW_MAX_PX = 1920;
 export const viewSceneTool = {
     name: 'view_scene',
     title: 'Look at the scene',
-    description: "Look at the building in 3D from a viewpoint you pick and get the picture back: the finished house, every storey and the roof by default, or an explicit Solo/Exploded level presentation, whatever view mode the person has on. Use it to compare what you built with a reference and say what differs before you fix it: the facade from the photo's own camera (camera: its position, aim, field of view and aspect), rendered at the photo's aspect to lay beside it; or from the photo's side at street height (from 'street', 'street-left', …, eyeHeight 1.7), in its light (lighting); one face square on (projection orthographic); the massing from above, or an aerial view (elevation 40). The view frames the target (a building, a level, a wall or a zone; the whole building, its roof included, by default) from outside, unless you place the eye yourself with position or camera. To stand inside a room and see its furniture and finishes at a person's height, give interior {zoneId} (a room: an id from get_zones or create_room): the eye stands in the room a step in from a corner, looking across it, with the cut below; from picks the side of the room it stands on, target something in the room to look at it. To see inside a floor, give interior {levelId}: the other floors and that floor's roofs and ceilings are left out of the picture, and everything on it, walls, openings and furniture alike, is cut at 0.65 of the storey's height (about two thirds), so a tall wardrobe or a door head is cut, not short; a roof level has no inside; with no eye given it looks down into the floor, or into the room or zone you target. A level below grade, targeted alone, is looked into the same way (from outside the ground would cover it), the ground over it drawn as a faint veil. The live view is not changed. A door, a window or an item on a floor frames at detail scale, an opening seen from its outside face: a close-up to lay beside the photo's crop of the same element, to see what differs. Over the MCP the user's editor tab open on the project renders the picture: with none open it is refused (editor_tab_required), a tab in the background must be brought to the front (editor_tab_hidden), and a tab that is open but busy or still loading answers editor_tab_busy: call view_scene again in a few seconds, the user need not be asked. Where the host keeps the picture it answers its viewId: name it to use that exact frame later (a Studio render of this view) without taking it again. A picture is not a measure: take sizes and counts from the tools.",
+    description: "Look at the building in 3D from a viewpoint you pick and get the picture back: the finished house, every storey and the roof by default, or an explicit Solo/Exploded level presentation, whatever view mode the person has on. Use it to compare what you built with a reference and say what differs before you fix it: the facade from the photo's own camera (camera: its position, aim, field of view and aspect), rendered at the photo's aspect to lay beside it; or from the photo's side at street height (from 'street', 'street-left', …, eyeHeight 1.7), in its light (lighting); one face square on (projection orthographic); the massing from above, or an aerial view (elevation 40). The view frames the target (a building, a level, a wall or a zone; the whole building, its roof included, by default) from outside, unless you place the eye yourself with position or camera. To stand inside a room and see its furniture and finishes at a person's height, give interior {zoneId} (a room: an id from get_zones or create_room): the eye stands in the room a step in from a corner, looking across it, with the cut below; from picks the side of the room it stands on, target something in the room to look at it. To see inside a floor, give interior {levelId}: the other floors and that floor's roofs and ceilings are left out of the picture, and everything on it, walls, openings and furniture alike, is cut at 0.65 of the storey's height (about two thirds), so a tall wardrobe or a door head is cut, not short; a roof level has no inside; with no eye given it looks down into the floor, or into the room or zone you target. A level below grade, targeted alone, is looked into the same way (from outside the ground would cover it), the ground over it drawn as a faint veil. The live view is not changed. A door, a window or an item on a floor frames at detail scale, an opening seen from its outside face: a close-up to lay beside the photo's crop of the same element, to see what differs. Where the host keeps the picture it answers its viewId: name it to use that exact frame later (a Studio render of this view) without taking it again. A picture is not a measure: take sizes and counts from the tools.",
+    surfaceNotes: {
+        mcp: "The MCP has no renderer of its own: an editor open on the project renders the picture, the user's own tab or, where the host offers one, an editor on its servers (each view it renders costs credits). A refusal says what to do: editor_tab_required (no editor can render it), editor_tab_hidden (the user's tab is in the background: it must be brought to the front), editor_tab_busy (a tab is open but busy or still loading: call view_scene again in a few seconds, the user need not be asked).",
+    },
     input: {
         target: z
             .string()