Developer-tools MCP server
Pascal 3D Editor
Version history of discovered tools, schemas, and declared agent authority.
OBSERVED INTERFACE
Capability surface
Modelara’s observed declarations are shown separately from its derived effect classifications.
- 26
- 27
- 36
- 0
Unknown means Valyd could not determine the capability's effect confidently from the declared interface and static evidence. It is not treated as safe.
- Package
- @pascal-app/mcp@1.1.4
- Registry
- npm
- Published
- Nov 12, 2026
- Integrity
sha512-tiPfygYi8oTJIL1WJJNIhAqigPxieo43w0j4AstSSU2wx4FIUPaAefmMCXRHSyFp4pkFnGhlDBAFR+Ujc5pCYA==- Analyzer
- modelara v0.1.8 · policy not recorded
- Repository
- https://github.com/pascalorg/editor
89 capabilities
| Capability | Type | Derived effect | First observed in Valyd coverage | Last changed |
|---|---|---|---|---|
add_columnpascal-editor:tool:add_columnObserved interface and hashesAdd a structural or decorative column at (x, z), or rebuild one by nodeId. role post makes the Build panel framing post: plain square pressure-treated wood, default 6x6 with no base, reaching the lowest beam above its support or the ceiling plane unless height is given. postSize and postBase use the tile choices. Refused with not_a_post when post choices are given without role post (or an existing post). Supports native fields or optional code using the same module and conventions as add_object, with floor mount and its bottom centre at the support point. Params named height, width and depth drive the native size controls. Only add columns when requested. Input schemasha256:effa0e0828b644a11ab51bd5c746d225fca7d58f5540cde67888f498dff0a369Output schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
add_corner_windowpascal-editor:tool:add_corner_windowObserved interface and hashesAdd a window that wraps the corner where two walls meet, one window on each wall joined at the corner, and return their windowIds and wallIds. Both run to the corner, the glass fused there (post none, a fixed window's default) or meeting at a thin post (post post). Any angle the walls make, a bay's 135° as well as a square or an acute corner. The corner is the point the two walls end at ([x, z], as get_walls gives their ends); width is how far the glass runs along each wall from the corner, the same on both unless widths names a wall. Each side is placed by add_window's rules (height, sillHeight, windowType, style the same on both sides; with no sillHeight, centred on the lower of the two walls). The walls are the level's (levelId, default the floor the person is viewing): stacked storeys share their corners' points. Refused with a code: no_corner where no two walls of the level end at the point, corner_ambiguous where more than two do (name two with wallIds), corner_angle for a corner nearly folded back or nearly straight, corner_not_fused for post none on a window type other than fixed, width_exceeds_wall. The editor's window panel shows the pair under Corner. Input schemasha256:e2c3806f519d7ecc425ca94a19050fefa98aad7fcc404289a7d961aff190efcdOutput schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
add_doorpascal-editor:tool:add_doorObserved interface and hashesAdd a door to an existing straight wall at t (0..1 along it), or a passage with no leaf (openingKind opening: a cased opening, an arch). The door slides to stay on the wall and reports clamped. On a railing (wallType railing) it is a gap in the guard as tall as the railing, with no leaf, casing or threshold. Refused with a code, as in the editor: curved walls, walls shorter than the door, a door taller than the wall top where it stands or anywhere along a sloped wall (wall_too_low), and overlapping another door, window or wall item unless force is set. Match the reference with the outline (rectangle, rounded, arch), doorType and style; what they cannot express (glass strips, a pattern of lites, carved panels) is written as a script in code, never left as not possible. Not available in run_batch: the host opening executor prepares scripted creation and rebuilds, which a batch does not prepare. Input schemasha256:c42400744ef1258e8e6f7332d8c1a9a51ee8520af7e9ab4b1fde1571f1b4dc32Output schemasha256:78882640eaff1ceffcf2c3d05a2a37f86cfdc6b995aab7d98d3f1862d63fab7fDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
add_fencepascal-editor:tool:add_fenceObserved interface and hashesAdd a fence along points on a level: one fence per side, a whole run or a lot's boundary (closed) in one call. Privacy (solid panels) by default; picket for a picket fence, slat for vertical slats, rail for open rails, horizontal for cladding boards, guard for a deck's barrier. Fences stand on the level, as the editor's fence tool puts them. Refused with a code: a side shorter than 10 cm (fence_too_short), a roof level (roof_level). Input schemasha256:f22cc0eb0d13602b27a71515b050a515b4079c088f0ae29a0cc570d31c5efc0bOutput schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
add_levelpascal-editor:tool:add_levelObserved interface and hashesAdd an empty level to a building as the editor does, above its top storey or below its lowest for a basement, and return its id, floor index and height. Above, it goes under the building's roof level, which moves up one so the roof stays on top; a basement goes one storey under the lowest level, every existing level keeping its place, the ground floor included. On a scene with no building (a new or cleared scene), it starts the scene as the editor does: a site, a building and its ground level. A level that ends up below grade says in its result how a new wall on it is built (wallConstruction): a wall against the ground is a foundation wall, built of what the building's region says: 8 in CMU with 2x4 pressure-treated furring laid flat inside (0.241 m) in the United States and where the scene does not say where the building stands, 25 cm cast concrete insulated and waterproofed outside (0.354 m) in Europe; the result names the region it read, a partition is an ordinary wall. To copy a floor with its content, use duplicate_level. Input schemasha256:6f11b019ab62150c3180fd2d36fcb2c168485df341dce7db29eddfc55ba3387eOutput schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
add_objectpascal-editor:tool:add_objectObserved interface and hashesAuthor parametric Three.js furniture, decor and custom objects of any shape, dimensions or style, whether or not the catalog holds something similar (the catalog is a limited set that varies by server). Examples include a low oak table, a slatted bench, a paper lantern, built-ins, custom columns and capitals, mouldings and trim, panels, exposed beams, ceiling bodies, canopies, a porch and railings. Pascal runs the module in a sandbox, stores the result and places it as one object the user can move, paint, and ask you to edit again. Module shape (import THREE from the three package as usual; the addons below too): // also available: three/addons/utils/BufferGeometryUtils.js, three/addons/geometries/{RoundedBoxGeometry,ConvexGeometry,LoftGeometry,ParametricGeometry}.js, three-bvh-csg (Brush, Evaluator, SUBTRACTION, ADDITION, INTERSECTION) export const params = { width: { default: 4.8, min: 3, max: 8, step: 0.1, unit: 'm', label: 'Width' } } export const mount = 'floor' // 'floor' | 'wall-side' (on a wall face) | 'wall' (through a wall, like a window) | 'ceiling' export default function build({ params, THREE }) { const group = new THREE.Group(); /* … */ return group } One object is one feature that changes together: a table, a bench, a porch, a railing run, a fireplace surround, a ceiling with its beams. Never a whole house, and never walls, rooms, floors, roofs, stairs, doors or windows: those have their own tools. A new object's reason records its design intent: what the authored shape, dimensions or style contributes to the request. The scene check lists every authored object with its reason; no catalog-exhaustion proof is required. On a floor, a plain box with a wall's size or a floor plate is refused with the tool to use (use_walls, use_slab); a detailed object with a wall's size (a bookcase, a screen), or one named after something Pascal builds, is built with a hint naming the tool. Conventions (they make the object work in Pascal; follow them): - Metres, Y up, modelled in its installed orientation. Floor and wall mounts put the bottom-centre of the visible bounds at the placement point. Ceiling mounts put the top-centre there: visible geometry extends down in negative local Y, with its top at Y = 0. Wall-side mounts put the bottom-centre of the back face there (back at Z = 0, facing +Z). Normalization translates geometry; it does not flip it. - Paint: name every material slot_<finish> (slot_trim, slot_frame, slot_metal) and reuse one material per finish; a material named "glass" renders as glass. A slot's colour is shown as the library finish it matches (wood, metal, the nearest flat colour); exact: true keeps each colour as written. - Parts: name the few groups a person would point at part:<id> (part:column_left, part:canopy, part:landing), usually 2–24, a group per part, not every mesh. Set userData.type on parts someone would look for: column, beam, slab, roof, railing, panel, trim, step, light. - Lights: add a THREE.PointLight or SpotLight named light:<id> where the bulb is; it becomes a switchable light. A SpotLight keeps its aim (its target), angle and penumbra (a sconce's cone, a recessed downlight). castShadow = true makes it cast shadows (only the couple nearest the view do at once, so keep it for the lights that shape a room). userData.glow = { size, strength } draws a soft halo around the lamp in its colour (size across in metres, about 0.15 for a sconce to 0.4 for a lantern; strength default 1), strongest at dusk and night. - Motion: put THREE.AnimationClips on the returned group's .animations, as in any three.js project; tracks target <objectName>.<property> or <object.uuid>.<property> and may use any transform property (position, rotation, rotation[y], quaternion, scale); material and visibility tracks do not animate. A clip named open becomes the object's open/close control (close plays a clip named close, or open reversed); a clip named loop runs continuously; every other clip gets its own play toggle labelled with its name (name it for the person: "Twirl", "Music"). Write as many clips as the object needs. - Cuts: a mesh named cutout cuts only the mounted host; cut:wall, cut:ceiling and cut:slab require that host kind (floor items cut their support slab). The hidden cutter must reach the host; walls use its real shape, ceilings and slabs its through-hole footprint. - Sockets: an empty Object3D named anchor:<id> marks where other things attach. - No textures, network or DOM. At most 300k triangles (every instance of an InstancedMesh counts), 32 materials, 60 m per side. Blender instead (language 'bpy'): when the shape is easier with Blender's modelling (bevelled or rounded edges, subdivision-smooth and organic forms, booleans, curves and text, solidify, array, screw and other modifiers), write a bpy module: import bpy, bmesh PARAMS = {"width": {"default": 1.8, "min": 1.2, "max": 2.6, "step": 0.05, "unit": "m", "label": "Width"}} MOUNT = "floor" def build(params): ... # add objects to the empty scene; everything in it is exported, modifiers applied The same conventions in Blender terms: metres, Z up, the front faces -Y (Blender's Front view); part:<id>, light:<id> (a point or spot light object; its custom properties intensity sets the brightness, default 2, shadows = True casts shadows, glow = {"size": 0.2, "strength": 1} draws the halo), anchor:<id> (an empty), cutout, cut:wall|ceiling|slab and collider are object names; userData is the object's custom properties (obj["type"] = "panel"); slot_<finish> are material names. A clip is one action named open, close, loop or anything else, assigned to every object that moves in it. Use the data API and bmesh, not operators that need a 3D viewport. A Blender build takes a few seconds. Several objects: they do not depend on each other, so several add_object calls can go in one step, or in one run_batch call (a call per object; each is reported on its own with its receipt, and one that fails does not stop the others). From words instead of code: pass piece (what it is in your own words, its size and mount) with name, category and reason. Pascal's own model writes its module in the background under these conventions, compile-checked and repaired, many at a time; the call answers at once with the piece's id and status pending, so go on working. Where the host offers it; each piece spends credits. Given position (or parentId), the object is placed there when its module lands; given neither, it is only made, and author_scene items place it, as many times as they name its id (piece). A piece that fails comes back in author_scene's report. Edit: pass nodeId with new code and/or params (params alone rebuild the stored script; get_source provides the current code and params when needed); identity, placement, paint and the params you leave out are kept. The result lists the size, parts, slots, lights, animations and params. Input schemasha256:3dd2c76cb5d79ced0550e175186a58690181fb502fa895de55eb9b0f30d8d766Output schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
add_wallpascal-editor:tool:add_wallObserved interface and hashesAdd a single wall between two points on a level, straight or, with curveOffset, an arc. type applies a preset or project wall assembly including its thickness (unknown_wall_type for an unknown id). wallType railing builds the Build panel guard: default post-and-rail, 0.9144 m high, thickness from railing.postSize, no assembly or foundation. Its doors are gaps; windows refuse railing_window, skirting refuses railing_wall. railing settings on a standard wall refuse not_a_railing; type on a railing refuses railing_wall. Refused with a code: a level that is not a storey (a declared roof level), and a wall shorter than 1 cm. On a level below grade, a standard wall against the ground (on the outline of the walls of the level) is a foundation wall, built of what the building's region says: 8 in CMU with 2x4 pressure-treated furring laid flat inside (0.241 m) in the United States and where the scene does not say where the building stands, 25 cm cast concrete insulated and waterproofed outside (0.354 m) in Europe; the result names the region it read; a partition inside the outline is an ordinary wall; the result says which. Input schemasha256:9d4e70a729b69fa5d7c727fc1acc773d01fb2955018f400eb93d34c47ba38b5cOutput schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
add_windowpascal-editor:tool:add_windowObserved interface and hashesAdd a window to an existing straight wall at t (0..1 along it), centred vertically on the wall, or on sillHeight above the floor when given. It slides to stay on the wall and under the wall's ceiling, and reports clamped. Refused with a code, as in the editor: curved walls, railings (railing_window: a railing takes a door, a gap in its guard), walls shorter than the window, a window that fits nowhere under a sloped wall's top (wall_too_low), overlapping another door, window or wall item unless force is set, and a style on a window that is not Fixed (style_needs_fixed_window). Match the reference with the outline (rectangle, rounded, arch), windowType and panes (columns × rows, or a style); what they cannot express (glass strips, leaded lites, a feature frame) is written as a script in code, never left as not possible. Not available in run_batch: the host opening executor prepares scripted creation and rebuilds, which a batch does not prepare. Input schemasha256:2f51b33db2664b95a3f7ecf258bdb66235657bc75ddb0b0df2622aafae1af12eOutput schemasha256:f378f72c92ea94ecf61d5560eaa81d90c584bfc01265f8ff05c365cf041c67d0Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
analyze_floorplan_imagepascal-editor:tool:analyze_floorplan_imageObserved interface and hashesDefer to the MCP host (via sampling) to extract walls, rooms, and approximate dimensions from a floor-plan image. Requires host support for sampling. Input schemasha256:d93d956ade759a346daf42708b245c8633ce57e5ae0d97661c48638c3a5e49eaOutput schemasha256:93b93c24971707916ddab3e45857ac30effb7969c08c909f46ac09a74a2f9458Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
analyze_room_photopascal-editor:tool:analyze_room_photoObserved interface and hashesDefer to the MCP host (via sampling) to extract approximate dimensions, fixtures, and windows from a single-room photograph. Requires host support for sampling. Input schemasha256:e34808f2788188f83a9944ad3fc39a6223251906bbd60127201ce64e878ffd1eOutput schemasha256:e427bd49e2bea50d254afde73f63611454e4b31dc73673f59a3e88571fb09368Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
apply_patchpascal-editor:tool:apply_patchObserved interface and hashesApply a batch of create/update/delete operations atomically. All patches are validated before any are applied; the entire batch forms a single undo step. Batch-first is the default: prefer one apply_patch call containing all create/update/delete ops for a build step, in stable order so later ops can reference ids created by earlier ops. A single call is atomic (all or nothing) and pays the snapshot and save cost once; do not loop one-op calls. A create whose id already exists fails the whole patch with node_exists; to replace a node, delete it earlier in the same patch. An update cannot change id or type (identity_change) or object or children (immutable_field); restating the current value is fine. A parentId change must name an existing node that holds children and cannot point to the node or one of its descendants (invalid_parent). An update cannot add schema issues to a node (invalid_update). After a delete or a roof update that regenerates a roof's default gutters, those gutters and their downspouts are addressable only in a later call (regenerated_default). A roof created or moved onto the storey whose walls carry it goes to the level above them (the roof level over a top storey), said in notes; storey content (walls, zones, slabs, ceilings, items, stairs) on a roof level (roof_level), a walled level declared the roof level (roof_level_holds_storey) and floor indexes putting a roof level under a storey (roof_level_on_top) are refused. Refusals come back as a tool error whose text is JSON {code, patchIndex, id, message}. Input schemasha256:578849e44a11f1a8c51fcdc3cbca425331b6344abc79ecfef6f7da9ce404999bOutput schemasha256:f51b90933c661d5c53ccef6922cfca914dfe0b9ec32b40c5747685a8567ca593Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
author_scenepascal-editor:tool:author_sceneObserved interface and hashesTurn a whole design you wrote as free three.js into an editable Pascal scene: the payload holds the whole design. You read your own module however you like (its source, running it and reading the objects, both) and hand over a conversion payload: levels, walls (straight, curved or glass) with their openings, rooms (each naming its unit in a building of several dwellings or tenancies: a condo, an apartment building, a hotel; a room naming none is common area), slabs, voids, columns, railings, stairs, every piece of furniture as an authored object with its own module, and lights. Pascal does the rest server-side: compiles and stores each item, places it, derives the rooms and their floors, paints, runs its checks, saves, and answers with a gate report you iterate against. Nothing you hand over is silently dropped: what cannot be placed comes back by name with a reason, and what Pascal corrected (a wall end snapped onto the centerline it meets) is listed. Coordinates: metres, plan x/z, Y up, each level's floor at y = 0 in its own frame. A wall is its centerline; walls meet where centerlines meet, so end a partition on the centerline of the wall it runs into. An opening's 'along' is measured from the wall's start to the opening's centre; give each opening its type (how it opens) and style (its look), or its own module for a shape they cannot express. An item's position is where its bottom centre stands, except a ceiling item's (mount 'ceiling': a pendant, a ceiling light): it hangs from the ceiling of the room containing its plan position, its top on that ceiling, and its y is not read. A rug, a mat or a runner is an item lying on the room's floor. What stands on a floor stands on its finish: on a room with a floorCode, on the top of its planks or tiles, so its y stays 0. Its module follows the add_object contract (metres, Y up, built in its installed orientation; at most 300k triangles and 32 materials per item; name materials slot_<finish>; drawers, doors and lids as animation clips; a THREE light named light:<id> where a bulb is: a SpotLight for a cone, castShadow for shadows, userData.glow for a halo). A hex colour is written as an exact material, one per distinct colour. Pascal builds a wall's cap, the floor plate and the ceiling itself: fold a module's caps, underlays and floor planks into the wall, the room's floor finish and the room (say so in notes), never into slabs or regions: baseboards are the wall's skirting, a plank or tile floor is the room's floorCode (a terrace's decking or paving its slab's surfaceCode), tiles, panelling or boards on a wall are its faceLeft / faceRight (or the room's wallCode), cladding, brick or battens outside its faceOutside; a slab is a terrace, a platform, a balcony; a stair is its level's stairs, which open the floor above; the roof over the top level is roof, Pascal's own segments when its shape is one of theirs, else your geometry as roof items, both on the building's roof level above the top storey. Pascal draws what bold architecture needs natively: a curved wall is one wall with the point its arc passes through, through (never a run of short straight ones), a glass front a curtain wall, a double-height room a void in the floor of the level above it (its ceiling opens with it, a railing along its edges), an archway a passage with an arch shape. Paint a wall by what its faces look onto, colorInside and colorOutside: which face is inside is Pascal's to find. Build the building as it is built: a wall at its real height, nothing lowered or removed for viewing. Hand over the payload, or your module and its adapter, the program that reads the module and returns the payload: Pascal runs the adapter (one that throws comes back with its error, and nothing is written). A payload too large for one call can go by reference: payloadFile names a JSON project file that holds it. An item names its piece instead of code when add_object makes it from words; one still being made is written when it lands, with no call from you. Pieces made from words are written many at a time while you go on, so furniture made that way does not lengthen your turn the way pieces you write yourself do. One answer has an output limit, and the limit counts thinking and the call's arguments together; answers that planned and wrote a whole house as one payload have stopped there before the payload was complete. The payload is the whole design: a later call with replace: true removes what its payload leaves out, and a call without replace on a scene that holds a conversion is refused (conversion_exists). A conversion stores one module and one adapter, and only when it succeeds; a later call with replace: true and edits (each find text occurring exactly once) changes parts of them, and the adapter runs on the whole edited module. create_room, add_wall, add_door, add_window and create_stair add to the scene a call at a time. The report says what was written, what Pascal defaulted (defaults: a window with no type is fixed and cannot open), what it warns about but wrote (warnings: thin slabs, too many slabs or regions), what it refused (defects, by your ids), the items waiting for their pieces (pending), and Pascal's checks of what stands (checks, each passed or with what failed: doors and windows a person opens move, glazing is glass, every room's floor covered, every placed piece standing, nothing written as loose debris or buried, wall finishes built, stairs arriving inside a room clear of walls, every level holding rooms or walls: the ground, terraces and foundations belong to the ground level, Pascal draws the site and foundations; where units are named, every room in one or plausibly common). Call again with replace: true to revise the previous conversion: the module and adapter you leave out are the stored ones, edits change parts of them, and with neither a payload nor a module, adapter or edits the stored conversion is written again. Stable element identities and manual changes are retained; overlapping changes are refused. An existing building without a conversion baseline is never cleared. A payload by reference is a project file you upload: upload_project_file with phase prepare and its size answers a signedUrl; PUT the bytes there; then phase complete with the returned fileId and storageKey; that fileId is the payloadFile. A server that keeps no project files refuses payloadFile (files_unavailable); one that cannot run an adapter refuses the module and adapter (adapter_unavailable). Input schemasha256:29f645b1e684b483ca179dd74694d5c5dda3e38aaadd742670020ce02e6c1a1bOutput schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
check_collisionspascal-editor:tool:check_collisionsObserved interface and hashesAssess declared item footprints with a rotation-aware plan AABB test. Supports an explicit minimum clearance and reports units, source dimensions, skipped evidence, and unsupported checks. Optionally scope to one level or floor-standing items. Input schemasha256:e501dcd8f3a746399d10df925161fb693e25694e89cbc1005ddb30265a40f157Output schemasha256:f75520afb3c5b6a8f538474e14ee4ee9e7986480bf9666c4e1f8c908185b6b5aDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
clear_scenepascal-editor:tool:clear_sceneObserved interface and hashesEmpty the project on purpose, back to the default scaffold: a site, a building and one level of the standard storey height. It is the only way to empty a project: a write that would empty it is refused (scene_wipe_blocked), since that is far more often an accident. Call it only when the person asked to start over, and say what they asked in reason. Input schemasha256:62bb08eb0adc28e80f35edd5f908e5bf034cbdc3d634bfd551aa3ec721cf65a0Output schemasha256:3c7e66d2ebefbf6b46f967078d9cd0f09112d82ea1bf21d871bbe32f09e38047Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
create_from_templatepascal-editor:tool:create_from_templateObserved interface and hashesInstantiate a seed Pascal scene template into the bridge. Regenerates all ids before applying. When `save: true` and a SceneStore is wired, also persists the new scene and returns the SceneMeta. Input schemasha256:845e4ebfdf48fddbbfb5e18dbaeed7a087a9c3f9d95380e5f6592df52d503628Output schemasha256:575b859fb1d902d00bf13fbd72e76b11511810bc8db04f55e7d80537571091c4Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
create_house_from_briefpascal-editor:tool:create_house_from_briefObserved interface and hashesReplace the session's scene with a starter template and save it as an unpublished draft, returning its editor URL. The template follows bedroomCount, rooms and landscaping only: garden-house for landscaping or a garden, patio or yard room, else empty-studio up to one bedroom, two-bedroom for two and garden-house for more. brief, style and constraints neither choose nor shape it; the summary repeats brief. It saves into projectId's project, or a new one named projectName or after the template; with no scene store it saves nothing. Refine it with the semantic tools afterward. Input schemasha256:2fc83d16630c09fbc023d5105a30fc8ce2610cf03a40c5ba64366a4a95b72103Output schemasha256:14f3d306a34add543f1bfad10cb7d53955ca893745ba77f92d5186ee7952730bDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
create_mezzaninepascal-editor:tool:create_mezzanineObserved interface and hashesAdd an open-below room inside a host reference polygon, with a separate thin plate and railings on open edges. Minimum area 1 m²; elevation defaults to half the storey snapped to 0.05 m, thickness to 0.2 m. Elevation must exceed thickness and stay at least 0.3 m below the resolved footprint plane; overlapping mezzanines are refused. The host floor and walls stay intact. Input schemasha256:1ddcf611d2f5d4f6a356eb90c6ecbe45ea33b497317109a0877652f8b47aa16dOutput schemasha256:0b08ff7a147c2a234c7dccc4dc96432cf549bb4dfe97ae206f5a5c06a50bd41aDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
create_projectpascal-editor:tool:create_projectObserved interface and hashesCreate a browser-visible Pascal project for the authenticated user. Use this before save_scene when the user asks for a new project. Input schemasha256:9cf4be72c19af0b7dda0f2d6b381e84e8996250276ea7d70302f493f24b18b96Output schemasha256:8c7517b001ed94f32d234bdc26a36da6321aed70f10bc1b7db6fa321b48a7001Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
create_roofpascal-editor:tool:create_roofObserved interface and hashesCap a storey with a roof over its footprint (its walls' outline, else its floor plates, else its rooms), swept in the building's own axes into rectangles, one roof segment each. Without a roofType: a gable for one rectangle, hips for a few wings, flat for a large block. The roof goes on the building's roof level above the top storey (the empty level directly above when it is the only one; made, named Roof, when there is none), and stands on the storey's wall tops, so exploded and solo level views lift it off the plan. Glazed construction supports gable, straight shed and barrel. Barrel depth is the span; barrelRise is at most half the span. glazing controls frame, glass, grids and panels. Paint glazing-frame, glazing-glass or glazing-solid. Call it once the storeys and their exterior walls stand. Refused with a code: storey_above (another storey stands above: a roof caps the top one; a lower wing's roof is drawn with the Roof tool), building_required (no level named on a site of several buildings: pass a level of the one to roof), roof_exists (the storey already has a roof: edit it, or delete_node it first when the person asked for a new one), no_rooms (no rooms or closed walls on any level of the building: pass width and depth to roof a rectangle of your own). Input schemasha256:b8b1317abde17237a65b36ee9cfc82e8c68f08cf564e22b83bfd3b7b1df96aacOutput schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
create_roompascal-editor:tool:create_roomObserved interface and hashesCreate a room on a level from its polygon: a wall per edge, an edge a wall already runs along reusing that wall (rooms share their boundary with their neighbour), and the room zone that names it. The floor plate and the ceiling are derived from the room — never author a slab or a ceiling for it. Declare the room's doors and windows in the same call by polygon edge (wallIndex) and t along it, no wall ids needed; each is placed with add_door's and add_window's rules, and one that cannot be is skipped and listed in skippedOpenings with its code. Returns zoneId, slabId, ceilingId, wallIds in edge order (null where no wall), doorIds, windowIds. outdoor: true draws a terrace instead: separators where no wall runs, no walls of its own and no ceiling. Where the walls already enclose a room the reconciler numbered, the call names that room instead of adding a second one; where they enclose a room with a name of its own (not a number the editor gave it), it is refused (room_named_by_person) unless rename is true, which you pass only when the person asked for the rename, so a name is never changed silently. Not available in run_batch: the result needs the floor plate and ceiling derived by the host after reconciliation. Input schemasha256:4060811cfdd66c957875b2bc5c9bdb9e9b1c85841c94a8b5d97fa786ad0dee87Output schemasha256:f58c8ea0c2c50816f2d68c137c95b4c623919d711d45d52e852a8e2a07c8b9afDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
create_stairpascal-editor:tool:create_stairObserved interface and hashesCreate 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. GEOMETRY (get this wrong and the stair pokes through a wall): - (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. - 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. - 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. - 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). OPENINGS: 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 schemasha256:98ced0b36c95344feefcbe65c014452dea113e6549884e888292f66cf40c9471Output schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
create_story_shellpascal-editor:tool:create_story_shellObserved interface and hashesCreate one level-owned building shell from a footprint: the perimeter walls. The floor plate and the ceiling are DERIVED from the rooms the walls enclose — never author a slab or a ceiling here, and never pass boundary/autoFromWalls; createSlab / createCeiling / slabElevation are recorded as room intent instead. Use once per story; do not make first-floor walls span multiple stories. Input schemasha256:995547acf44e4979452e30e020e547d301bdea9575f691a95899afde83e7eb83Output schemasha256:37c54dd8099b827a40c585ab69b363358cd2e0654c19fd61ee099559f677812bDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
create_unitpascal-editor:tool:create_unitObserved interface and hashesA 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. Input schemasha256:b3d13277ed8073dd66807aaee5debee1d18feaabfd352fb0227d15a64047595dOutput schemasha256:4c2b95a40b636fc6f9e1be530e67bd5915aaad8152ab9cc397d1e6ae4c03ddb2Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
cut_floor_openingpascal-editor:tool:cut_floor_openingObserved interface and hashesCreate a persistent opening on a room or level from a polygon or rectangle. A floor cut also opens the automatic ceiling directly below; a ceiling cut can also open the floor above. Use cutsAdjacent:false for a one-surface cut. A mezzanine room cuts only its own plate. levelIds repeats the opening as a shaft on several levels. Input schemasha256:731bbc649b3f3c1f4e5e7a5882d2aea4a750a7448325a60c84cda77346dd3fc7Output schemasha256:0b08ff7a147c2a234c7dccc4dc96432cf549bb4dfe97ae206f5a5c06a50bd41aDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
delete_nodepascal-editor:tool:delete_nodeObserved interface and hashesDelete a node with everything under it, as the editor's Delete does: a wall goes with its doors and windows, a level with everything on it. The floors above a deleted level keep their index. Input schemasha256:a72bae37434847927600334476fa4616417198fabc1952c96c3d2c1c2a0e933dOutput schemasha256:a00786507c836d33336d9bb658e2c2a66151d08b091796227770c8819a906a79Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
delete_scenepascal-editor:tool:delete_sceneObserved interface and hashesRemove a stored scene by id. In Pascal this never deletes the project: it hides it from Pascal's public listings until it is next saved with content, and answers `deleted: false, hidden: true` with a message; its owner can delete it from the projects page. Only someone who can manage the project may hide it. A local scene store deletes the scene. Optionally pass `expectedVersion` for optimistic concurrency. Input schemasha256:02c96509d176d16201674609215e2dc2880345014b6f5ac88df6cf2d3be82e98Output schemasha256:5864920a1c79b710d6ccad7259790c880b84664b9b8acc103663ac4d35b86623Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
delete_zonepascal-editor:tool:delete_zoneObserved interface and hashesDelete a room. A room Divide made, which shares a separator (the editor's Separator: a room boundary with no wall) with a room on its outline, merges back into that room: the separators go, walls and items stay (mode "merge"). A room whose every boundary is a wall shared with other rooms is refused with a "shared-walls" conflict and nothing changes (mode "blocked"); delete one of its walls instead. Otherwise the room goes with its unshared walls, separators and their openings (mode "delete"), and contents chooses whether its items are kept or deleted. Returns the disposition payload. Input schemasha256:da558283ddadcc92dcd4d91ec85f86b1e7415da6f4706f7265e9752abf527cc4Output schemasha256:0b08ff7a147c2a234c7dccc4dc96432cf549bb4dfe97ae206f5a5c06a50bd41aDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
design_briefpascal-editor:tool:design_briefObserved interface and hashesRecord the request's design brief before furnishing, read axis by axis with a vision and where the objects come from, and return what it unlocks. It is written once for the whole request (piece by piece when the request invites it), each axis (action, size, form, facade, pieces, openings, style, materials, source, dressing) bounded by the person's own words or open with a design statement. It changes nothing in the scene. Furnishings are placed or made after a brief: place_items, furnish_room, place_in_room (the catalog's) and add_object, place_design (the agent's own), also inside run_batch. Before one, search_assets and view_assets read the catalog and every other tool works as usual; rooms, walls, openings and finishes are not furnishings. Bounded and open, in four readings. "a 4 by 5 m bedroom with a double bed, two nightstands, a wardrobe, one window, one door": action, size, form, facade, pieces (as a minimum: those pieces must be there, more may come) and openings bounded, the form and the facade by "a 4 by 5 m bedroom" (one room, no building designed); style, materials, source and dressing open. "add a lamp next to the sofa": action, form, facade and dressing bounded by "add a lamp" (one object in a room that exists, the building and its exterior stand as they are); style open, its design statement saying how this lamp is designed. "a bedroom with only a bed and a lamp": form and facade bounded by "a bedroom", pieces exact and dressing bounded by "only a bed and a lamp"; style and materials open, the bed and the lamp designed, not defaulted. "Build a house": the action bounded only by "a house"; every other axis open, the form, the facade and the dressing included, and rooms with an entry for each room. source open: technical equipment (sanitaryware, kitchen, laundry and climate appliances) and plants are placed from the catalog (place_items, place_in_room), every other catalog piece is made (add_object, place_design), and furnish_room, which places a whole stock set, stays closed. source catalog, brand or existing: place_items, furnish_room and place_in_room are open, and the creation tools stay open for what the catalog lacks. The form is the building's massing: a plan shape, a number of volumes, and whether the volumes stand at different heights. Open, its design statement says how the building is composed and massing states it: plan (polygon, rectangle, l, u, t, h, courtyard, wing, bay, detached), volumes (a count) and heights (one or several). Bounded, the person's own words fix the form ("an L-shaped house", "a single-storey bungalow") and massing may state what they fix; a request that builds or changes no building bounds it by its own words, the building standing as it is. The facade is the exterior identity of the building: its materials, the bands and elements it carries, the rhythm of its openings. Open, its design statement says how the exterior is designed and treatment states it: cladding (brick, stone, render, siding, wood, metal), bands (base, course, cornice), elements (corners, surrounds, shutters, balconies, entrance, curtain-wall, porch, guard, posts) and rhythm (regular or free: openings stacked storey over storey, or placed one by one). Bounded, the person's own words fix the facade ("une façade en pierre avec volets", "a black timber-clad house") and treatment may state what they fix; a request that builds or changes no building exterior bounds it by its own words, the exterior standing as it is. rooms lists the rooms the request builds or refits, when it builds or refits more than one (a single-room request or a focused edit carries none; an open form owes them): for each, name (as the scene names the room), use (bedroom, bathroom, kitchen, living, dining, office, hallway, laundry, garage, other), distinct (one line: what sets the room apart from the other rooms of its use, who it is for and its character), finishes (floor and walls as short phrases, tiled and skirting as true or false, and dressing when its walls are dressed) and pieces (its main pieces: furniture, fixtures, equipment). Rooms of the same use are distinct rooms, each with its own distinct line. Naming a piece (a double bed) states its function; its form, size within reason and finish are open unless the request fixes them. The pieces a request names are what the room must contain, not all it may contain: where the dressing axis is open, beyond states that design layer by layer: textiles, light, windows, walls, floor, plants, objects, small furniture, each a list of pieces or { none: why }, at least 6 of the 8 layers naming pieces; where the dressing is bounded (words that limit the pieces or the action, such as "only", "nothing else", "just"), none in every layer is accepted. The pieces the request names, read as a minimum, do not bound the dressing. The answer hands the pieces back as dressing. A source other than open is set by the request, not chosen: sourceQuote holds the person's own words that name it, at least two words naming a brand (the brief's brand), the catalog or what is already there ("IKEA furniture only", "que du catalogue", "use my existing furniture"); a request that names no source is open. The next design_brief replaces the brief in force. Refused: axis_missing (an axis other than form and facade is absent), axis_quote_not_in_request (a bounded axis's quote is not in the person's message), axis_open_without_design (an open axis without a design statement of at least 3 words), form_massing_missing (an open form without its massing: plan, volumes, heights), form_massing_inconsistent (one volume stated as detached or at several heights), facade_treatment_missing (an open facade without its treatment: cladding or elements, and rhythm), rooms_missing (an open form with no rooms), room_distinct_missing (a room without its distinct line), rooms_identical (two rooms of one use with the same distinct and the same pieces), dressing_bounded_by_minimum (the dressing bounded by words inside a pieces quote read as a minimum), brand_required (source brand without a brand name), source_quote_required (a source other than open without sourceQuote), source_not_named (the quote names no brand, catalog or existing source), source_not_in_request (the quote is not in the person's message), beyond_too_thin (dressing open, fewer than 6 layers naming pieces). There is no person's message here: a source quote must still name its source, and no quote is compared with a request. A brief lasts for the session. Input schemasha256:34352519a3d61354e8ce17c980479e078a22c92d424b2bf9717f2885b6179a15Output schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
divide_zonepascal-editor:tool:divide_zoneObserved interface and hashesDivide a room with an open path (endpoints snap to its boundary; the seed side keeps its id) or a closed island (outer room keeps its id). The two rooms are parted by a separator (the editor's Separator: a room boundary with no wall), not a wall. Supply path or the legacy two-point cut. Islands need 0.25 m² and 5 cm wall clearance. Input schemasha256:386c7808718e6f272565c20ad63f1d2b54cb336843510e16a150482197e22a8aOutput schemasha256:0b08ff7a147c2a234c7dccc4dc96432cf549bb4dfe97ae206f5a5c06a50bd41aDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
duplicate_levelpascal-editor:tool:duplicate_levelObserved interface and hashesCopy a level with everything on it, as the editor does: fresh ids, internal links kept, and units whose rooms are all on that level copied too; plan references, scans and spawn points stay behind. The copy goes above the original (or below it) and the floors past it move up one. Input schemasha256:662f65f032b5652b994e860ee96f460f2e4414bcd9b6bead304523d6408e8fe8Output schemasha256:dab8f2f855214e94ba8e7b642b0be0ca9692b530c7ee3f10be07f1c0fa6e7f55Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
duplicate_nodepascal-editor:tool:duplicate_nodeObserved interface and hashesDuplicate nodes with everything under them, as the editor's Duplicate does, and return each copy's id beside its source's. The copies get fresh ids, hosted children are re-hosted on them (a wall brings its doors, windows and wall items, their wallId pointing at the copy), and an id inside another listed subtree is skipped rather than copied twice. A door, window, wall item, ceiling item or roof piece copied on its own stays on its same host. offset [dx, dz] in plan metres moves every copy from its source's seat (default [0, 0], an exact copy in place, as the editor's duplicate starts); a wall offset translates its ends, a hosted copy's offset slides it on its host, clamped to stay seated. targetLevelId puts level-parented copies on that level instead; a hosted copy refuses it (hosted_root_level) because its host stays behind. Returns copies (sourceId, copyId, type, descendantCount), totalCreated and skippedIds. Refusals: node_not_found, duplicate_not_supported (a site, building, level — use duplicate_level — zone — use duplicate_zone — roof or roof segment, or a derived plate), duplicate_root_invalid (a node the editor only copies as part of its parent), hosted_root_level, level_not_found. Input schemasha256:f457ced2db029fe86ad180a0b6049d4791a32da14f30cd751f43c503f6e55a93Output schemasha256:ee4a00b81c0f3b43240e0dc08557eadfd8a913d9b612e8557a2cb3bde990eee5Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
duplicate_zonepascal-editor:tool:duplicate_zoneObserved interface and hashesCopy room intent and contents with fresh IDs; shared walls are copied without openings. Rotation is radians about Y before translation. Collinear destination walls are merged, preserving their IDs and hosted children. Crossings split walls and rooms re-derive; overlap is allowed. Force can reposition obstructing openings only when they fit. Input schemasha256:b9c1766dc9088bd65645e81cb930f8d52d781ae65fb4fa816a0e8a7b6ea31e8dOutput schemasha256:0b08ff7a147c2a234c7dccc4dc96432cf549bb4dfe97ae206f5a5c06a50bd41aDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
edit_collectionpascal-editor:tool:edit_collectionObserved interface and hashesCreate, rename, recolour or delete a collection, or add and remove its elements. A collection is a named set of any scene elements (lights, windows, doors, columns, objects built with add_object…), listed in the editor's Collections; being in one changes nothing about the elements. Without collectionId the call works on the scene's collection with that template, or else that name, and creates it when there is none. Input schemasha256:07ece084c991cd1586d3fb80580bbee973e700273e084a9cf5bff640ee21e21bOutput schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
export_glbpascal-editor:tool:export_glbObserved interface and hashesGLB export is not available in headless mode — it requires the Three.js renderer, which is browser-only. Returns a structured `not_implemented` tool error. Input schemasha256:e1097cff90b6f86e9ecdf741b342bcf4f2770598982ab4e2c24d5d3278636bacOutput schemasha256:6f901bdbd77c6e5fbd5251e88d84fd2639d03ef1599b4d217f76cf8542d5ee2aDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
export_jsonpascal-editor:tool:export_jsonObserved interface and hashesReturn the scene as a serialized JSON string. Pass `pretty: true` to indent with 2 spaces. Input schemasha256:20b87042176ae4352cff182a7291b91731f70607a0f7e53925973186013ab3c3Output schemasha256:16b366a1038d5676f0d16ee0277432207519d5b0cdaaca53a13308373796e4bcDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
find_by_typepascal-editor:tool:find_by_typeObserved interface and hashesFind every node, item, light or scripted part of one type in the scene, wherever it lives, and return the matches with their count. A type is a node kind (column, door, window, wall, stair, imported-mesh, a plugin's kind…), an item category, light (any item that emits light), or a part type inside scripted objects, windows and doors (a porch's columns, a window's grille). Narrow it to a level, a parent, a zone or an importer's source ids; without a type, every node the other filters match. A word that names nothing (no node kind, nor an item category or part type in this scene) is refused with the kinds the scene holds. Each result gives the node's id, name, kind, level and parent, with its metadata and provenance when it has them (one over 1 KB is named in omitted instead); get_node reads a node whole. Parts are read-only: they come back with their object's id, the part id and, for objects directly on a level, its bounds in level coordinates; edit them through their object. count says how many match; past limit (200 unless asked) the rest are left out of results, with truncated: narrow the call or raise limit. Input schemasha256:87cfffabad9d00210130054a48bb300359e39d4586c57642221e0751fd9ed49aOutput schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
fit_stairpascal-editor:tool:fit_stairObserved interface and hashesExplicitly replace stair riser proportions with uniform risers from design targets. Optionally fit going by changing flight runs or arc sweep; preserves landing elevations. Optional straight, L or U layout replaces the flight chain with width-sized turning landings or quarter-turn winders. Winder going is measured along the selected walking line. One atomic edit. Input schemasha256:4343999c7f715595ad6669e4dc22388dce616d5700eab751909b7541089ac907Output schemasha256:94e3f5aae01cabeaa2cf5c0a1fa4cdb66477b754c4686de0432cd57a2d52a954Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
furnish_roompascal-editor:tool:furnish_roomObserved interface and hashesPlace the catalog's fixed furniture set for a room type: one set per type, not matched to a style. The bed, sofa, counters or toilet go against the wall facing the door, the rest along a side wall, each set off its wall by its own depth. Name the room by zoneId (its level and outline come with it), or give its polygon and level. The door wall is the edge a door of the room stands on, else doorWallIndex, else edge 0. Nothing lands in a door's clear zone or on another item: a piece that does not fit is nudged, else skipped, and skipped says why. Items stand on the room's level. The set per room type: bedroom: double-bed (a side of 3.2 m or more) or single-bed, two bedside-table, dresser (10 m² or more), closet (13 m² or more); kitchen: kitchen (back wall of 2.6 m or more) or kitchen-counter, stove (back wall of 3.5 m or more), fridge; bathroom: toilet, bathroom-sink, bathtub (6.5 m² or more) or shower-square; living: sofa, coffee-table, livingroom-chair, tv-stand; dining: dining-table, two dining-chair (four when both sides are 3 m or more); laundry: washing-machine, drying-rack; entry and hallway: coat-rack (both sides 1.4 m or more); storage: closet. The result lists each piece placed with its size and id, and each piece skipped with its reason. view_scene with interior { zoneId } shows the room from inside, at a person's height. Input schemasha256:bcf5a4f13f3430fb2d99db0b3ef64c0e93e10f1c61292f00f58e7da18ed0cd64Output schemasha256:17dcca5d7ba6073d4b9264a74e4fc293415f6e1ba2df9bb1c23a343cb4c07105Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
generate_variantspascal-editor:tool:generate_variantsObserved interface and hashesGenerate N variations of a base scene by forking and applying seeded mutations. Example: "give me 5 variations of this kitchen". If `save=true`, each variant is persisted via scene operations and returned with an id + URL; otherwise the graph is returned inline. Input schemasha256:9e15f0dd1c339a0cbffd23ba6587520760b4f56033116bb91d2279764632bb17Output schemasha256:977359aba8ff9b1542147d09227ba10793b934f3ad9fc9058094b8001cd17bdcDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
get_level_summarypascal-editor:tool:get_level_summaryObserved interface and hashesSummarise one level so nothing on it goes unseen: its role and counts, then walls (length, heights, doors and windows), zones (name, area, size, floor_choices), slabs, ceilings, items (floor, wall and ceiling), floor openings, stairs, roofs, and anything else by type. Zone polygons: get_zones; a node's full data: get_node. Input schemasha256:c35cf6d53cff565f9dbfe9e24c3cbc2064879f2d9848fbf9dbbb3fceee814063Output schemasha256:e9516c58618ad8cfd842fe09f49c47fc7c6a589377ee274930136ea1c4d9f2e2Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
get_nodepascal-editor:tool:get_nodeObserved interface and hashesGet the full data of any node by its id: its fields as stored, with what the scene decides for it beside them (a wall's or a ceiling's resolvedHeight, and heightIsExplicit, false when it follows its storey; a wall's resolvedThickness; a door's or window's resolvedOpening, its floor and what it hangs from; the displayName a level or a floor plate is shown by); its ancestorIds, its parent first (a door's wall, then the level, the building, the site); and the scene materials (scene:<id>) its finishes use. A container's node lists its children as stored; any that name no node are listed again in missingChildIds. A node its schema rejects comes back as stored, with nothing derived (verify_scene says what is wrong). Input schemasha256:a72bae37434847927600334476fa4616417198fabc1952c96c3d2c1c2a0e933dOutput schemasha256:743d21a43cc4e8e0e706e6867f7b0e473b223e940b4efd8c1a3658d875a257f9Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
get_project_statuspascal-editor:tool:get_project_statusObserved interface and hashesAuthoritative status/debug call for a Pascal project: editor URL, browser-visible version, latest saved version, published version, node count, and graph hash. Input schemasha256:2704c0607cb754d4f63ac034c7a4571c52f97adf9bf823f7d905c95ca8316884Output schemasha256:8c7517b001ed94f32d234bdc26a36da6321aed70f10bc1b7db6fa321b48a7001Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
get_scenepascal-editor:tool:get_sceneObserved interface and hashesReturns the full scene graph: flat node dictionary, root node IDs, collections, and explicit installed plugin IDs when present. Input schemasha256:e1097cff90b6f86e9ecdf741b342bcf4f2770598982ab4e2c24d5d3278636bacOutput schemasha256:5e77085551b4efa869f3240528028d40ab27a66d1af369a08934241f59f04f6cDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
get_sitepascal-editor:tool:get_siteObserved interface and hashesRead the site a building stands on and return, in its level coordinates, its lot, buildable area, street side, north, ground and the footprint's yards. It gives the lot and its area, with the footprint a house usually covers on it (30 to 45%); the buildable area inside the setbacks with its centre, its area, each edge's frontage and depth, and its front edge (behind the street; while no street is recorded, behind the edge facing north, which the setbacks take as the front); the street side with the lot's frontage and depth on it; north; the ground (sloped with its fall, read flat, or not read); the address, parcel and zoning when known; whether the lot is only the new-project placeholder; and where the footprint sits now with its yards. Input schemasha256:0b23767001f344aa210bfa0098d05b05be6df9493c914472a62accf2d6a2919aOutput schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
get_sourcepascal-editor:tool:get_sourceObserved interface and hashesRead the code module a scripted node runs and return it with its language (three.js or Blender bpy) and its params at their current values. It reads the module of an object, or of a window, door or column built from code; a room's id reads its floor script, the module that builds its floor finish; a slab's id reads its surface script, the module that builds its top's finish; a wall's id with face reads that face's script (face may be left out when only one face has one). Optional source evidence when the current module is needed. An edited module can be passed back with the same nodeId: to add_object for an object, to add_window / add_door / add_column for their respective kinds. Input schemasha256:56af3cad01a192ac799361a2d513a7665342159841d5cc474d43183481726155Output schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
get_wallspascal-editor:tool:get_wallsObserved interface and hashesGet the walls of a level: start and end in metres, length, stored and resolved height, thickness, wallType (standard, railing or curtain; standard when absent), type ({ id, label } for a known assembly preset or project wall type, null otherwise), and their doors and windows. wallTypes lists available assembly type ids and labels for add_wall.type and set_wall_type. wallFaceChains gives base-chain provenance for geometric faces a (left of start → end) and b (right): ref (authored face slot), legacy (inline spec), or default (declared fallback ref). These are not final rendered finishes: room intent, face paint regions, exterior assembly cladding and reference availability can change appearance. A chosen white or default-matching ref is legitimate; fallback alone is not a defect or a requirement to paint. Input schemasha256:c35cf6d53cff565f9dbfe9e24c3cbc2064879f2d9848fbf9dbbb3fceee814063Output schemasha256:198b29593569d1a2cdd23d4f5c5500ea519e73ee2fb7a1b9ed6db3a033fb5b36Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
get_zonespascal-editor:tool:get_zonesObserved interface and hashesGet the zones (rooms) of a level: name, colour, polygon and holes in metres, area in m² (holes taken out), bounding size, roomType (room when absent, porch, deck or patio), floor.drop (step-down in metres, 0 when absent; an explicit floor.elevation takes precedence), porchFraming (auto, postSize, postSpacing in metres, beamSize, postCount and beamCount of existing generated parts; null when no outdoor/framing intent), and decking (boardSize, gap in metres, direction; resolved defaults for decks or when settings exist). auto follows porchFraming.auto; absent, on for a covered porch, off for decks/patios. false leaves framing to hand edits. These names and units match set_zone_intent. Includes the unit it belongs to (unitId and unit, its name; null: common area), and floor_choices: available floor plates (key, plateId, name, current; drawn and mezzanine flags). A room shares its floor plate with adjacent rooms unless detached. Persisted wall intent is wallMaterial (string, null when absent) and wallOverrides (wallId, geometric face a or b, finish; [] when absent), not a final rendered finish: local overrides and face paint can take precedence; absent intent is not a defect or a requirement to paint. Input schemasha256:c35cf6d53cff565f9dbfe9e24c3cbc2064879f2d9848fbf9dbbb3fceee814063Output schemasha256:09bb602819575ebda8b45bf190b6681a455e8b852c340343a51a32dad1798c6fDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
list_collectionspascal-editor:tool:list_collectionsObserved interface and hashesList the scene's collections with their elements (id, name, type, level), and the templates a collection can start from. Input schemasha256:05c175e742627beb495bd503cbb1f93aef225d298fcdf4ff2f5acfe57444c983Output schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
list_levelspascal-editor:tool:list_levelsObserved interface and hashesList every level of every building in floor order: id, name, floorIndex, building (parentId), role (occupied storey, roof-only level or support level), child count, gradeStanding (at-grade, partly-below-grade or below-grade against the ground line and the terrain), isGroundLevel, and which one the person is viewing (isActive); groundLevels names, per building, the level at grade (levelId, whether the building names it, floorElevation, gradeElevation, floorOverGrade, seated). A roof-only level is the roof, not a storey. Input schemasha256:e1097cff90b6f86e9ecdf741b342bcf4f2770598982ab4e2c24d5d3278636bacOutput schemasha256:085432fb4f6c20da32df5a4f01985440a7ef397570eb458ab1298246c1349369Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
list_scenespascal-editor:tool:list_scenesObserved interface and hashesList scenes in the SceneStore. Optionally filter by `projectId` and cap results with `limit` (default 100). Input schemasha256:dcec259f32dfc25af29acdbab3dbccc08b1db4c9167ce27607f2d1eede8fd17cOutput schemasha256:b410e7f079e51ff01d43bbae26fbfdfdc2a3be1bf30e4195d26ff57003d97805Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
list_templatespascal-editor:tool:list_templatesObserved interface and hashesList the seed Pascal scene templates available to `create_from_template`. Returns the id, display name, one-line description and node count for each. Input schemasha256:e1097cff90b6f86e9ecdf741b342bcf4f2770598982ab4e2c24d5d3278636bacOutput schemasha256:42b94115980815bb38d20d25bdb3ff74cda320890bfc5dd8b0176545a269aff6Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
list_unitspascal-editor:tool:list_unitsObserved interface and hashesA 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). Input schemasha256:ae75e66fdea71e4a649dc5035827d12e1f371597a06766a4fc574cad5f3c75a7Output schemasha256:bdba3a033be687e21f9192f47099b5bf0617f976ca50e0abbed54c2281f199d7Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
load_scenepascal-editor:tool:load_sceneObserved interface and hashesLoad a scene from the SceneStore into the bridge. Returns the scene metadata. Throws `scene_not_found` if the id does not exist. Input schemasha256:2704c0607cb754d4f63ac034c7a4571c52f97adf9bf823f7d905c95ca8316884Output schemasha256:f73d6d0679391c4b798b7d5325d21059e152786290b0b46cec2ff8e80bd75006Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
lock_outside_facespascal-editor:tool:lock_outside_facesObserved interface and hashesKeep the building's outer size: put exterior wall faces on their fixed reference lines, moving wall bodies inward so walls thicken inward and later thickness edits preserve outer dimensions. Supply either levelId or zoneIds. Input schemasha256:ee7df4d3f640ea136c7b4840474caab7139feb45effa67a9c7406a6411617252Output schemasha256:0b08ff7a147c2a234c7dccc4dc96432cf549bb4dfe97ae206f5a5c06a50bd41aDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
measurepascal-editor:tool:measureObserved interface and hashesMeasure the distance (in meters) between two nodes, or the net area of a polygon node when fromId === toId. Distance is between world-space reference points, returned as fromPoint/toPoint: a positioned node's origin in its host's frame (an item's base, a door's or window's centre in its wall), a wall's or fence's midpoint at its base, a slab's, ceiling's or zone's polygon centroid on its plane, a block's or imported mesh's vertex-bounds centre, a level's plan centre on its base plane, and another container's descendants' centre. `approximate` lists nodes whose renderer derives the pose from data not modelled here (a downspout at its gutter outlet, a gutter at the eave), with the reason. Input schemasha256:75785c8156b59d8b069f67680847f305c8f934d25749be56524f85fcab986a65Output schemasha256:a9c249114704ee507dc25b303bb13abef73a6cef048e471e402732f04aa8f45bDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
measure_stairpascal-editor:tool:measure_stairObserved interface and hashesInspect actual flight risers, walking-line going, slope, arrival, uniformity, headroom against floors, ceilings and stair bodies, and design-target diagnostics without changing measured geometry. Input schemasha256:10f64d1f6a0c8ebb605f0ef9ddd9c4db4ac0c623111d4606619bf40c87d558c5Output schemasha256:afab84b7436c982e392efdb6804cccacf88568ecf5ce438eef8e84ce0896f508Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
merge_windowspascal-editor:tool:merge_windowsObserved interface and hashesMake two windows that exist one window, as the editor's Merge windows does: nothing is recreated. On two walls that meet at a corner, each window within 0.30 m of that corner, they become one corner window (the add_corner_window result): each is slid to the corner keeping its width, the glass fused (post none), and both take the first window's height, sill and type, so name first the window whose look you want; the corner is refused over 170° or under 10° (walls_not_meeting, corner_angle, window_not_at_corner, height_exceeds_wall). On one wall, two windows with at most 0.30 m between them and nothing between become one window spanning both outer edges, from the lower sill to the higher head, with the first window's type and style (windows_not_adjacent, opening_between). Refused with a code and a sentence that says why: window_not_found, not_a_window, same_window, window_not_on_wall, window_already_joined (unwrap it first), windows_already_joined, opening_overlap (sliding to the corner would land on another opening). Returns kind (corner or same_wall), the windows that stay (windowIds) and the one that went (removedIds). Use it for two windows already built that open a corner or one wide opening; add_corner_window builds a new pair, and verify_scene's corner_unjoined names two windows this joins. Input schemasha256:f52c9536bf5bc5fca2d7788d5ee0ba86ba7a0407f1ff13f85dd768da182fc230Output schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
merge_zonespascal-editor:tool:merge_zonesObserved interface and hashesMerge two rooms by removing the separators they share (the editor's Separator: a room boundary with no wall). Walls are preserved; wall-only boundaries return a conflict. Input schemasha256:ae8a9e971584b9cf5208fa2876edb5008fc2bb4b42f0718b1dba3331b31d4bbdOutput schemasha256:0b08ff7a147c2a234c7dccc4dc96432cf549bb4dfe97ae206f5a5c06a50bd41aDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
move_nodepascal-editor:tool:move_nodeObserved interface and hashesMove one node as the editor's move tool does, re-seated on its wall, ceiling, roof segment or level, and return where it now sits and whether it clamped. A door, window or wall item slides along its wall (the plan point is projected onto the wall, clamped to stay on it, and refused with opening_overlap where it would hit a sibling, unless force, like holding Alt); a ceiling item moves in plan under its ceiling, keeping its drop; a floor or free node moves in plan on its level, keeping its height; a roof piece (skylight, chimney, vents, solar, dormer) moves in its segment-local plan, the frame its stored position uses, its height staying anchored to the segment surface; a wall takes by only (its ends translate, its openings ride in their wall-local seats). to and by are plan metres [x, z]: level plan for level, wall and ceiling hosts, segment-local for a roof host. Exactly one of to (absolute) or by (delta), or rotation alone. y is a window's sill height or a wall item's bottom height in metres, and nothing else takes it. rotation is yaw in degrees for free, ceiling and roof nodes. Returns the host class and id, the node's stored position after the move (a wall: its start point as [x, 0, z]), and whether the seat clamped. Refusals: node_not_found, node_not_movable (site, building, level, zone — use move_zone — roof, roof segment, stair, derived plates and other geometry-defined kinds), move_target_required, move_target_ambiguous (both to and by, or to on a wall), move_host_missing (its wall, ceiling or segment is gone), curved_wall, wall_too_short, wall_too_low, opening_overlap, rotation_not_supported (wall-hosted nodes face their wall side), height_not_applicable, move_not_supported (an item resting on another item). Input schemasha256:08178a7c0487651d69e38cdfa97ac4fb39aabce37c8c3b05e3c0825e221777b3Output schemasha256:83a2320ebb16c4118fa7d8d75726f43e5c0b4506c0be3b81c5c336d57056eadeDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
move_roofs_to_roof_levelpascal-editor:tool:move_roofs_to_roof_levelObserved interface and hashesMove the roofs a storey holds on its own walls to the level the roof rule gives them, and return the roofs moved and the level they went to. It does what a roof's panel does by hand (Move to the roof level): over the top storey, the building's roof level (made, named Roof, when there is none); under an upper storey, that storey. Each roof stands exactly where it stood, its segments, finishes and id kept: only the level holding it changes, so exploded and solo level views show the storey's plan with no roof over it. For a project built before roofs had their own level, when verify_scene reports roof_mixed_in_storey. Refused with a code: level_not_found, no_roof_on_walls (the storey holds no roof standing on its walls; a porch roof on its beam and a lower wing's roof on the storey above already sit where they belong). Returns the roofs moved (roofIds), the level they went to (roofLevelId) and the roof level made for them (createdRoofLevelId). Input schemasha256:dc9393ceac05d2282884c188f95b5b3beca5c6112e26d98197c11458a6144aa3Output schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
move_zonepascal-editor:tool:move_zoneObserved interface and hashesMove room intent and contents. Shared walls and openings stay with neighbours; the room takes plain copies. Rotation is radians about Y, before translation, about the room centroid unless a pivot is supplied. Crossings split walls and overlaps re-derive rooms. Force can reposition obstructing openings when they fit; otherwise the edit is refused. Input schemasha256:b7ae73f56f6eaf227916dd07d840e576d37071805cc06b6be3bb51abd779c594Output schemasha256:0b08ff7a147c2a234c7dccc4dc96432cf549bb4dfe97ae206f5a5c06a50bd41aDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
paintpascal-editor:tool:paintObserved interface and hashesGive walls, slabs, ceilings, roofs, columns, fences, doors, windows, stairs, blocks, cabinets, shelves, items and the other built parts a finish in one call, as the editor's Paint does. Give one finish: color (#rrggbb, painted with the nearest of the library's flat colours, said with how near; with exact: true, that colour itself, a matte scene material); material, a library:<id> (find it with search_materials) or scene:<id> ref, or a native material {properties: {color, roughness, metalness}} for an exact finish, kept as a scene material (materialName names a new one) and reused when the scene holds an equal one; or erase: true, back to the surface's default. role picks the surface: a wall's face a or b, or exterior and interior (the faces turned out of its rooms or into them, else by its stored sides; a partition is interior on both; a wall whose sides are unknown, or with rooms along only part of a face, is refused: name its face, a or b), its trims aSkirting, bSkirting, aCrown, bCrown, aChairRail, bChairRail (skirting, crown or chairRail: that trim on both faces), a curtain wall's curtain-frame, curtain-glass, curtain-solid; a slab's surface, side, edge, riser, underside or foundation; a ceiling's surface; a roof's top (the covering), edge (the gable ends and the trim band), wall (the soffit and the deck edge, and the fascia and rake boards unless they have their own) or fascia (the fascia and rake boards, a fascia band); a glazed roof's glazing-frame, glazing-glass or glazing-solid; a column's shaft, base, capital or frame; a fence's posts, infill, base or rail; a door's panel, frame, glass or hardware; a window's frame, glass, hardware or shutters; a stair's treads, body or railing; a block's body; a cabinet's front, carcass, countertop, plinth, hardware or glass; another part's own slots, which a refusal names; an item's surfaces by the names its model gives them (its painted ones are in get_node's slots), which paint cannot check. Without a role: both faces of a wall, a slab's or a ceiling's surface, a roof's top, a glazed roof's frame and solid panels, a column's shaft, a whole fence, a door's panel and frame, a window's frame, a block's body, a part's one surface. A roof shows one finish per surface: a segment's finish goes on its roof, and a roof's on all of its segments. A glazed segment holds its own glazing finishes: a roof's glazing roles go on its glazed segments, its other roles on the roof, and without a role both. A wall face is painted whole, over the wall finish of the room it faces; its painted parts keep their own, named in the note. A ceiling shows its finish's colour, not its texture. The result says the finish written, and the scene material when there is one. A target that is not in the scene, a role it lacks or an unknown material refuses the whole call: nothing is painted. Input schemasha256:343453452f6de91dcce9bd9f1019718704c71009e29bf402e547215e458c8b04Output schemasha256:a2ed1dbf1961a1d581e5d3b1ec25a5e9a085d50a75f4f52e536f037ab6fbb6f0Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
photo_to_scenepascal-editor:tool:photo_to_sceneObserved interface and hashesOrchestrator: analyse a floor-plan photo via MCP sampling, translate the structured vision result into a Pascal SceneGraph (site → building → level with walls and zones), optionally save it, and swap the bridge to the new scene. Requires host support for sampling. Input schemasha256:9edcd623237ae9c5e1acd730905342768fa6780cdfffc008454cf3703834ecdbOutput schemasha256:5670571cef0d66cfdeb182fdaf4546195ceaa14bf3f184b6246578309b61216dDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
place_buildingpascal-editor:tool:place_buildingObserved interface and hashesStand a building on its site before or after its walls go up. It moves only the building node, so walls, levels and roofs keep their coordinates and move with it. The footprint (outline, the plan you are about to draw, in the coordinates you will draw it; else the walls standing) lands centred in the buildable area, or at the yards a site plan or the person gives. A building with walls keeps its rotation unless rotationDeg is given (get_site's squareRotationDeg squares it to the street); one with none yet is turned square to the street. Fences, paths and plants on its levels move with it. Input schemasha256:7e7e9c0617ef9cab62274b9c69b8845a4566551acde0ce6530c478d260ef44c3Output schemasha256:71a88cdbfb09faad0d4a20a0109abfaf732d79179814c073da2a7334aae88ce2Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
place_designpascal-editor:tool:place_designObserved interface and hashesCreate one instance of a design (procedural item recipe, object or JSON string) in the scene. The design must pass validate_design. Its mounting picks the host: floor designs go on a level (or a slab or zone of it) or on a named surface of a placed design; wall-side designs on a straight wall face; ceiling designs under a ceiling. Only creates: refusals carry a code (invalid_design with diagnostics, design_version_not_enabled for version 2 designs until the next release, design_too_large above 24 KiB, invalid_placement, node_exists, host_not_found, wrong_host, unknown_surface, does_not_fit) and change nothing. Input schemasha256:2f46485d7c31789ee86ee8513a47471552b222aebfd18e993f85bbac80e2a3f5Output schemasha256:53736316a992769170a5e8023073b08219ada2c8ebab8641e1e5dcc27bcefd7dDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
place_in_roompascal-editor:tool:place_in_roomObserved interface and hashesPut one floor-standing catalog item in a room where it fits, without working out a position. Wall/ceiling-attached assets need a host: place_items accepts targetNodeId and, for a wall, y for the bottom height. A wall-bound floor piece (fridge, counter, stove, sink, TV stand, dresser, wardrobe, sofa, bed, bedside table, toilet, bath, shower, bookcase, cabinet) stands against a wall, centred in the widest free stretch of that wall (clear of every door and every other item), its front toward the room; it is never put in the middle, and when no wall has room the answer says how wide the widest free stretch is. A free-standing piece (dining table, rug, coffee table, plant, armchair) takes the middle of the room, or goes with what it belongs with: a coffee table and an armchair face the sofa. A chair goes around its table, one call per chair, facing the table, and is refused when the room has no table. Explicit edge, align, offset or inset instead requests a wall free run for any floor piece. Name the room by its zoneId (create_room, get_zones), or by its polygon and level. The item is a catalog id from search_assets. To furnish a whole room by its type in one call, use furnish_room. Input schemasha256:2937c696d65a4a8dc6574438e49e0a9fb8bbe24182fc9343d540e911933844abOutput schemasha256:8e347fe94254820195fb938a50e436dbc38e1a5ee06a164438c26080a75e1a8aDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
place_itemspascal-editor:tool:place_itemsObserved interface and hashesPlace one or more catalog items (furniture, fixtures, plants, art, lights) in one call. Each assetId is a known catalog id, available from search_assets results or existing scene item data, never guessed. Positions are level (x, z) metres. An item stands on the floor of the level, or on the host it names (targetNodeId): a wall (art, a sconce: y is the height of its bottom above the floor, required; it goes on the side of the wall the point is on), a ceiling (a pendant, a downlight: it hangs flush under it), or an item standing on the floor (a lamp on a nightstand: it rests on its top; on an object built with add_object it rests on the real surface under the point, such as a porch landing, or a ceiling item hangs from the underside above it, such as a sloped vault, and the result names it in restingOn). A room, a slab or a level as the target means its floor. Each item is placed or refused on its own (asset_not_found; outside_rooms: an indoor item on the floor outside every room of a level that has rooms — garden and outdoor items may stand outside; height_required, item_too_tall, unsupported_host, host_not_found, host_not_on_level; blocks_door: a floor item standing where a door needs space, with a spot in its room that clears every door; too_large_for_room: a floor item its room cannot hold in any turn). Input schemasha256:7da334449d2c53cefb7085fae3c386decf86240f8ff7a235152aa63d92da0791Output schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
rebase_floor_referencepascal-editor:tool:rebase_floor_referenceObserved interface and hashesChange or clear one or more footprint reference datums in one atomic edit, compensating supported storey offsets so existing world geometry stays in place. Supply slabIds together for a shared storey. Input schemasha256:c7531e85c04ce6f798f6aba21be956529b734068001f92c57a56aa4b522a50d3Output schemasha256:0b08ff7a147c2a234c7dccc4dc96432cf549bb4dfe97ae206f5a5c06a50bd41aDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
redopascal-editor:tool:redoObserved interface and hashesRedo the next N previously-undone steps (default 1). Returns the number of steps actually redone. Input schemasha256:53c3dfb7881ef322765173a75eb790f54aa8de0fac8924a48fcc80d1794d0db9Output schemasha256:1e40ea019936d69865578bab39e8ea0b6e560f7ffd87637cb59e54042a42f783Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
remove_floor_openingpascal-editor:tool:remove_floor_openingObserved interface and hashesRemove an authored floor or ceiling opening and restore the derived surfaces it cut. Input schemasha256:47cdc5d20833d21e70989ca8cf8147634e5d7fd60e0ae106c56b78219eb94a3fOutput schemasha256:0b08ff7a147c2a234c7dccc4dc96432cf549bb4dfe97ae206f5a5c06a50bd41aDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
rename_scenepascal-editor:tool:rename_sceneObserved interface and hashesRename a scene in the SceneStore. Returns the updated SceneMeta. Optionally pass `expectedVersion` for optimistic concurrency. Input schemasha256:cf96fc42be60d4ca464eafd4c2d3746ccf0589c8b8841de781f29fa4091a9463Output schemasha256:d67c147af01ae4249313b568f16a1eb620980a6d072853a0465fbc31dc658f1bDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
rotate_zonepascal-editor:tool:rotate_zoneObserved interface and hashesRotate a room by quarterTurns 1 or -1 about its centroid, then align its first reference vertex to gridStep (default 0.5 m). Crossings split walls and collinear overlaps merge. Force can reposition obstructing openings only when they fit. Input schemasha256:a5a88aacc871e35bc8318fcc5b9cf0e43658868a4339c54e3959412de0eb9baaOutput schemasha256:0b08ff7a147c2a234c7dccc4dc96432cf549bb4dfe97ae206f5a5c06a50bd41aDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
run_batchpascal-editor:tool:run_batchObserved interface and hashesOptionally run several scene tools in one call: in order, each on the scene the calls before it left, applied as one undo step, with a report per call. Supports repeated or known-in-advance work; individual calls remain available. A call cannot use an id another call of the same batch creates; created ids are available in the report for subsequent calls. onRefusal stop (default): a refused call stops the batch and nothing is applied; skip: the others are applied and each refusal is reported. This policy includes unsupported tools, invalid inputs and design-brief refusals, as well as runtime refusals. add_object calls are independent of each other under both: one that fails is reported with its own error and the others are applied, each with the receipt a single add_object gives. Tools: paint, search_materials, list_levels, get_node, get_level_summary, get_walls, get_zones, duplicate_level, verify_scene, delete_node, move_node, duplicate_node, measure_stair, fit_stair, find_by_type, create_roof, add_wall, set_wall_type, add_fence, add_level, create_unit, create_stair, add_corner_window, merge_windows, add_column, add_object, place_design, place_in_room. Input schemasha256:d64d32573724db389917734054296e1f9992d916a6f3e278cd44e627e7675bc2Output schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
save_scenepascal-editor:tool:save_sceneObserved interface and hashesSave the current scene (or a provided graph) to the SceneStore. Without id or projectId it saves to the project this session is bound to (create_project or load_scene). Defaults to a browser-visible draft save so agents can iterate without creating many project versions. Use saveMode: "checkpoint" for meaningful version history. Input schemasha256:fe562d8997e81d56555b22bae14d818b3a9072101ba915c7fba426d8a04aadd3Output schemasha256:ed5baf2846fd79e8527ab5ace925badbe721e4de3f12f3914fd576b81b671d98Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
search_assetspascal-editor:tool:search_assetsObserved interface and hashesSearch the item library (furniture, fixtures, lights, plants, outdoor) by keyword, with one or several queries in a call. The catalog is a limited set that varies by server: what a search returns is what exists. Results provide valid asset ids and placement facts when these are not already known. A query matches the items whose name, id, category or tags hold every one of its words. Returns one group per query, best matches first (the name exactly, then words of the name, words starting it, the category, a tag), at most limit items (24 unless set, up to 60); total counts every match and truncated says the limit cut some, with a hint on how to narrow. Each item has its id, name, category, dimensions [width, height, depth] in metres and attachTo (null on the floor, else 'wall', 'wall-side' or 'ceiling'). An item with params is built from code and listed before plain models the query names as well: once placed, add_object with its nodeId and new params resizes or reshapes it to the room. Related lookups (sofa, coffee table, tv stand) can share a call. Input schemasha256:c03c21e0bd96910cbe2eee06fa122eb24b21196f0f4e5ef1bc82b4d916e92febOutput schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
search_materialspascal-editor:tool:search_materialsObserved interface and hashesSearch or browse the material library (the finishes paint gives), several queries in one call: find a library material's ref here rather than guessing it. The library is Pascal's materials and, in the editor, the ones it holds besides (the community's, yours, your workspace's). A query's words match the words of a material's id, name and kind, or a piece of its id (plank48, cco), building words as the library writes them (timber is wood, weatherboard is siding, render is stucco), colour words by its shade (dark, light, white, grey) and surface words (roof, wall, floor, ceiling) by what it suits; a word of one or two letters, or one as common as 'the', searches nothing. Without a query, a browse lists by name every material of its kind, or that suits its surface (flat colours suit every one), or the whole library. Returns one group per query: each material's ref (library:<id>), name, kind, the surfaces it suits and its colour, best first (a browse by name), 12 at a time for a search and 150 for a browse; the words no material answers (missing), so a finish the library lacks is said, not guessed; and on a long list how many more there are (more) and the offset that lists them (next). Input schemasha256:0c9158c11250ebab316adbd6a77df22dfe4a4f6389bcfda13809f2ac16b793d2Output schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
set_checkpointpascal-editor:tool:set_checkpointObserved interface and hashesName this moment of your work (a roof, a floor, a batch of walls) for verify_scene({ since: name }) to compare against, and return the checkpoints kept. verify_scene then lists what was created, changed and deleted since, grouped by level and kind with a view each, and what you made that is gone. "start", the beginning of your work, is always one; a name used again replaces the first; a session keeps at most 8. A checkpoint is kept with your session, not in the project: it changes nothing in the scene, enters no undo, and does not restore anything. Refused: too_many_checkpoints (naming them), scene_too_large, name_required. Input schemasha256:96ea53ca85df016a6b1020cb33cf4b2cd9c5d9adee504076a1eb30c898040da9Output schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
set_floor_foundationpascal-editor:tool:set_floor_foundationObserved interface and hashesSupply slabId or slabIds; grouped plates receive the same floor-top displacement, while edge slots apply only to the first plate. A ground-contact floor has two inputs: thickness (slab, min 0.01 m, grows upward from the foundation) and foundationHeight (0 = on the ground, no foundation; > 0 = raised on a solid foundation; foundation.type "solid" alone raises it 0.3 m, "none" puts it on the ground). The floor top is derived and never floats: grade + foundationHeight + thickness; everything the floor carries (walls, openings, items, rooms, storeys above) moves with the top. Legacy floorHeight (a target top) maps to foundationHeight = top - grade - thickness, never below 0; null = on the ground. On upper plates the underside stays on the walls below: thickness (or floorHeight as a target top) changes the top; only ground-contact plates accept a foundation. Explicit room floors translate with the floor to preserve steps. Input schemasha256:180c43ad50af99d4746115a69d506b3e4eb0613f3dc44a8768c3d96b374a51abOutput schemasha256:0b08ff7a147c2a234c7dccc4dc96432cf549bb4dfe97ae206f5a5c06a50bd41aDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
set_ground_levelpascal-editor:tool:set_ground_levelObserved interface and hashesMake a level the building's ground floor: the one standing at grade, its floor on the ground. A building's levels stack on a ground line; the levels with a lower floor index are below grade (basements), the ones at or over it are not, and list_levels reads it as groundLevels (levelId, floorElevation, floorOverGrade, seated) and each level's gradeStanding (at-grade, partly-below-grade, below-grade) and isGroundLevel. This names the level on the building, seats the building so that level's floor datum stands on grade (flat site: world Y 0; sculpted terrain: the mean ground height under its floor), moving the building in height only — the plan stays where it is and every level keeps its place relative to the others — and renumbers the floor indices so it is 0 and the ones under it are -1, -2…. A level added below (add_level position below) stacks under the lowest level without moving the ground floor. A roof level or a support level cannot be the ground floor (not_a_storey). One undo step. Refusals: level_not_found, not_a_level, no_building, not_a_storey. Answering unchanged: true when the level is already the named ground floor, on grade, at index 0. Input schemasha256:a37bcc4ca6bfe11ad98bfbbfc3f15ffa3bc5b8379ba086cc84cf7673854ec589Output schemasha256:3ba6b65f27eabbb7a68322a7d251be566ef9e46684679ae47851ed53a20630d8Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
set_room_floor_constructionpascal-editor:tool:set_room_floor_constructionObserved interface and hashesEdit the single floor volume associated with a room, with the same patch as set_floor_foundation. On a ground-contact floor: thickness (slab on the foundation, grows upward, min 0.01 m) and foundationHeight (0 = on the ground; > 0 = raised on a solid foundation); the top is derived as grade + foundationHeight + thickness and carries everything on the floor. A drawn slab takes thickness, finishes and a numeric floorHeight (its top) only. Supply slabId when the room spans multiple construction domains; an absorbed legacy slab is edited through its derived base plate. Input schemasha256:c35657c6eb6898ccb592d2d8e72ad487897062deeac454ce38beadc7218ec16eOutput schemasha256:0b08ff7a147c2a234c7dccc4dc96432cf549bb4dfe97ae206f5a5c06a50bd41aDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
set_unit_memberspascal-editor:tool:set_unit_membersObserved interface and hashesA 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. Input schemasha256:39f559bd0df45f7df722560caf6e68ea26b2ef7792eee94c8bfd610bf583ab9eOutput schemasha256:2caa175b806479714a21cee7d24f5d2efdaa13935e07da65b85d08ce1a19b48fDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
set_wall_typepascal-editor:tool:set_wall_typeObserved interface and hashesApply an assembly type to existing standard walls, copying its layers and total thickness as the wall panel does. type null clears the assembly and keeps thickness. All walls change together. Refused with unknown_wall_type for an unknown type id, target_not_found for a missing wall, curtain_wall or railing_wall for walls that take no assembly. Input schemasha256:6e9b75d2de8b5db6365edb7fcd956b3926ff8245137dfb1d380a64bdc7b324feOutput schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
set_zonepascal-editor:tool:set_zoneObserved interface and hashesCreate a polygonal zone on the given level. label is stored as the zone name and properties are merged into metadata. A polygon along walls that already enclose a room is that room, never a second zone: a room still named "Room N", or already named label, takes the label and properties; a room a person named otherwise is refused (rename it with update_node only when the person asked). Input schemasha256:74944401bed7bbc1dda49c85ee47373e186fe45902ae4d5d262938944aed35c5Output schemasha256:ae989e286826ca2c1d08009909a0b6e60789c289a8cd7b483baeb3b2b2659decDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
set_zone_intentpascal-editor:tool:set_zone_intentObserved interface and hashesUpdate a room's intent in one patch (name, floor, ceiling, steps, walls, daylight, outdoor type, porch framing, decking) and return how many changes it made. It sets the room name, floor finish/elevation/regions and floor.footprint ("new" mints a unique floor key tied to this creator room, an existing key joins that floor on this level, null returns to the shared floor). Touching rooms with the same key share a base plate; disconnected pieces share construction settings. Conversion preserves world geometry in one edit and refuses when infeasible. get_zones exposes floor_choices. A keyed floor uses "<creator room name> floor" while the creator remains on that key; otherwise it uses the largest named room. Existing keys such as "own" without a creator use that fallback. A user-given plate name wins; the shared floor stays "Shared floor". Keyed rooms can have raised or sunken floor.elevation, stored as a level-local walking top. Slab thickness, foundation height and edge finish use set_room_floor_construction, updating every piece of the key. Update ceiling paint regions (ceiling.regions: [x, z] polygons with a finish, later wins), step finishes (floorStepFinish for every step of the room; floorStepOverrides: [{ key, step?, finish }] per doorway, key = the door id the step sits under or the lower room id), wall material and construction opt-outs. daylight { artificialLight, mechanicalVentilation } declares a habitable room lit and aired by artificial means (the IRC R303.1 exceptions to daylight; both true), stored in the room's metadata; a bedroom, living room or kitchen needs a window to outside or this declaration, above and below grade alike. roomType ("porch" | "deck" | "patio", null for a room) makes the room outdoors: a porch is a concrete slab stepped floor.drop (1.5 in) under the house with a ceiling, a deck wood decking 1 in down and framed, a patio concrete and open. porchFraming { auto, postSize "4x4"|"6x6"|"8x8", postSpacing m, beamSize e.g. "6x8" } sets the posts of a covered porch (one at each outside corner, more at most postSpacing apart) and the beam on them under its ceiling; a deck or patio gets them only with auto true (to carry a roof over it). A size or the spacing rebuilds them, auto false leaves them as edited. decking { boardSize "5/4x6"|"2x6"|"2x4"|"composite", gap m (1/8, 3/16 or 1/4 in), direction "parallel"|"diagonal"|"perpendicular" to the house } sets a deck's boards (default 5/4x6, 1/4 in apart, along the house); its frame follows: joists 12 in on centre under diagonal 5/4 or composite boards (IRC R507.7), and along the house on beams square to it under boards running out from it. Absent fields are unchanged; null clears. Input schemasha256:754e3a082806465930e464b44ba88ba953cd966e8272bfaed86ea7082067b048Output schemasha256:0b08ff7a147c2a234c7dccc4dc96432cf549bb4dfe97ae206f5a5c06a50bd41aDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
undopascal-editor:tool:undoObserved interface and hashesUndo the most recent N steps in the scene history (default 1). Returns the number of steps actually undone. Input schemasha256:53c3dfb7881ef322765173a75eb790f54aa8de0fac8924a48fcc80d1794d0db9Output schemasha256:9bec7546610244924c07df9704b8f849ff8b32729edc6486ab0fa510fbd299adDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
validate_designpascal-editor:tool:validate_designObserved interface and hashesCheck a design (procedural item recipe) without changing the scene. Write it from pascal://schema/design (JSON Schema, rules and a valid example); a floor design has no mounting. Returns `valid`, coded `diagnostics` (errors block placement, warnings flag floating or unbalanced parts), the parameter `sweep`, and `measurements` at the given parameters: bounds, per-part bounds and instances, true triangle counts, draw groups per slot, datum contact and connected components. A design that does not match the schema gets every schema error at once, each with its `path`, what is `expected` there and what was `received`, plus `schemaUri` and a valid `example`: fix them all before calling again. Rules the schema cannot express are checked once it matches, each error with a `hint`. Version 2 designs validate fully but carry a design_version_not_enabled warning: placement accepts version 1 only until the next release. Input schemasha256:e9a359be7de0f3b465f785ba7412316fbc25672dde4ec719b19226ac9414fc52Output schemasha256:ec5a263a993874db108f07f858f6e41037ace68cc05f608d61ec5d2f76f80ce8Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
verify_scenepascal-editor:tool:verify_sceneObserved interface and hashesOptional 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. 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. Input schemasha256:8e5bf3ef8e53635017a5b330e58d2bf684fb13200ade243929a61b74b384890fOutput schemasha256:a418a0bfd0007e3c8180040e73ab58add35b442463b01b48a9c47b62f7eec2dfDescription hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
view_assetspascal-editor:tool:view_assetsObserved interface and hashesPictures of catalog items by id, each with its size and the names of its paintable surfaces (paint takes one as role). Input schemasha256:9186414c53350af7ccde116a3635c0b1900cf8f5067f5e26fc7ab349a579abbeOutput schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed | |
view_scenepascal-editor:tool:view_sceneObserved interface and hashesLook 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. 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 schemasha256:37fdf41842c64ecdd3e946b157fe672baa5add2a7b6cb318faedc1512e4c1a1fOutput schemaNot exposed in the analyzed interface. sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1Description hash: Interface hash: Other observed Modelara metadata | tool | 1.1.2 | No change observed |
No capabilities match these filters.
STATIC COMPARISONS
Release history
- 1.1.3 1.1.4PASS0 added0 removed0 schema0 write0 destructive0 unknown
- 1.1.2 1.1.3PASS0 added0 removed0 schema0 write0 destructive0 unknown