@ifc-lite/sandbox 1.14.2 → 1.14.3

package/dist/bridge-schema.js

@@ -7,22 +7,42 @@ import { IfcCreator } from '@ifc-lite/sdk';
 // ============================================================================
 /** Simple registry for IfcCreator instances managed by the sandbox */
 const creatorRegistry = (() => {
-    let nextHandle = 1;
-    const creators = new Map();
+    const nextHandleBySession = new Map();
+    const creatorsBySession = new Map();
+    function getSessionCreators(sessionId) {
+        let sessionCreators = creatorsBySession.get(sessionId);
+        if (!sessionCreators) {
+            sessionCreators = new Map();
+            creatorsBySession.set(sessionId, sessionCreators);
+        }
+        return sessionCreators;
+    }
     return {
-        register(creator) {
-            const handle = nextHandle++;
-            creators.set(handle, creator);
+        registerForSession(sessionId, creator) {
+            const handle = nextHandleBySession.get(sessionId) ?? 1;
+            nextHandleBySession.set(sessionId, handle + 1);
+            getSessionCreators(sessionId).set(handle, creator);
             return handle;
         },
-        get(handle) {
-            const creator = creators.get(handle);
+        getForSession(sessionId, handle) {
+            const creator = creatorsBySession.get(sessionId)?.get(handle);
             if (!creator)
                 throw new Error(`Invalid creator handle: ${handle}`);
             return creator;
         },
-        remove(handle) {
-            creators.delete(handle);
+        removeForSession(sessionId, handle) {
+            const sessionCreators = creatorsBySession.get(sessionId);
+            if (!sessionCreators)
+                return;
+            sessionCreators.delete(handle);
+            if (sessionCreators.size === 0) {
+                creatorsBySession.delete(sessionId);
+                nextHandleBySession.delete(sessionId);
+            }
+        },
+        removeSession(sessionId) {
+            creatorsBySession.delete(sessionId);
+            nextHandleBySession.delete(sessionId);
         },
     };
 })();
@@ -62,6 +82,487 @@ function toRef(raw) {
     }
     return null;
 }
+function mapNamedProperties(properties) {
+    return properties.map((property) => ({
+        name: property.name, Name: property.name,
+        value: property.value, Value: property.value,
+        NominalValue: property.value,
+        type: property.type, Type: property.type,
+    }));
+}
+/** Methods with non-standard signatures that need hand-written wiring */
+const SPECIAL_METHODS = new Set([
+    'constructor', 'toIfc', 'setColor',
+]);
+/**
+ * Explicit allow-list of IfcCreator methods exposed in the sandbox.
+ * Only methods in this set (or in SPECIAL_METHODS/ELEMENT_METHODS/ZERO_ARG_METHODS)
+ * are wired. This prevents accidental exposure of private/internal helpers.
+ */
+const ALLOWED_METHODS = new Set([
+    // Spatial structure
+    'addIfcBuildingStorey',
+    // Building elements
+    'addIfcWall', 'addIfcSlab', 'addIfcColumn', 'addIfcBeam',
+    'addIfcStair', 'addIfcRoof', 'addIfcGableRoof', 'addIfcWallDoor', 'addIfcWallWindow', 'addIfcDoor', 'addIfcWindow',
+    'addIfcRamp', 'addIfcRailing', 'addIfcPlate', 'addIfcMember',
+    'addIfcFooting', 'addIfcPile', 'addIfcSpace', 'addIfcCurtainWall',
+    'addIfcFurnishingElement', 'addIfcBuildingElementProxy',
+    // Specialized profiles
+    'addIfcCircularColumn', 'addIfcIShapeBeam',
+    'addIfcLShapeMember', 'addIfcTShapeMember', 'addIfcUShapeMember',
+    'addIfcHollowCircularColumn', 'addIfcRectangleHollowBeam',
+    // Generic element creation
+    'addElement', 'addAxisElement', 'createProfile',
+    // Properties and materials
+    'addIfcPropertySet', 'addIfcElementQuantity', 'addIfcMaterial',
+    // Low-level geometry
+    'getWorldPlacementId',
+]);
+/** Methods that take (elementId, def) instead of (storeyId, params) */
+const ELEMENT_METHODS = new Set([
+    'addIfcWallDoor', 'addIfcWallWindow',
+    'addIfcPropertySet', 'addIfcElementQuantity', 'addIfcMaterial',
+]);
+/** Methods that take a single params object after the handle */
+const SINGLE_DUMP_METHODS = new Set([
+    'createProfile',
+]);
+/** Methods with zero args (just need the handle) */
+const ZERO_ARG_METHODS = new Set([
+    'getWorldPlacementId',
+]);
+function classifyMethod(name, _fn) {
+    if (SPECIAL_METHODS.has(name))
+        return 'special';
+    if (ZERO_ARG_METHODS.has(name))
+        return 'no-args';
+    if (SINGLE_DUMP_METHODS.has(name))
+        return 'single-dump';
+    if (ELEMENT_METHODS.has(name))
+        return 'element-params';
+    return 'storey-params';
+}
+/** Humanize a method name for the doc string */
+function methodDoc(name) {
+    // addIfcWall → 'Add an IfcWall'
+    // addElement → 'Add a generic element'
+    // createProfile → 'Create a profile from a ProfileDef'
+    if (name === 'addIfcBuildingStorey')
+        return 'Add a building storey. Returns storey expressId.';
+    if (name === 'addIfcGableRoof')
+        return 'Add a dual-pitch gable roof. `Slope` is in radians. Returns roof expressId.';
+    if (name === 'addIfcWallDoor')
+        return 'Add a door hosted in a wall opening. Position is wall-local [alongWall, 0, baseHeight]. Returns door expressId.';
+    if (name === 'addIfcWallWindow')
+        return 'Add a window hosted in a wall opening. Position is wall-local [alongWall, 0, sillHeight]. Returns window expressId.';
+    if (name === 'addElement')
+        return 'Create ANY IFC type with a profile at a placement. Returns expressId.';
+    if (name === 'addAxisElement')
+        return 'Create ANY IFC type extruded along a Start→End axis. Returns expressId.';
+    if (name === 'createProfile')
+        return 'Create a profile from a ProfileDef union. Returns profile ID.';
+    if (name === 'getWorldPlacementId')
+        return 'Get the world placement ID for use with addLocalPlacement.';
+    if (name.startsWith('addIfc')) {
+        const entity = name.slice(3); // remove 'add', keep 'IfcWall' etc.
+        return `Add ${entity}. Returns expressId.`;
+    }
+    if (name.startsWith('add')) {
+        const what = name.slice(3);
+        return `Add ${what}. Returns ID.`;
+    }
+    return `Call ${name} on the creator.`;
+}
+const CREATE_METHOD_SEMANTICS = {
+    project: {
+        taskTags: ['create', 'repair'],
+        useWhen: 'Start a new generated IFC model before creating storeys and elements.',
+    },
+    toIfc: {
+        taskTags: ['create', 'export'],
+        useWhen: 'Finalize the in-memory IFC model and produce STEP content for preview or download.',
+    },
+    setColor: {
+        taskTags: ['visualize', 'repair'],
+        useWhen: 'Assign a named RGB color to a created element using [r, g, b] values between 0 and 1.',
+    },
+    addIfcBuildingStorey: {
+        taskTags: ['create', 'repair'],
+        requiredKeys: ['Elevation'],
+        useWhen: 'Create a building storey container before adding level-based geometry.',
+    },
+    addIfcWall: {
+        taskTags: ['create', 'repair'],
+        placement: 'storey-relative',
+        requiredKeys: ['Start', 'End', 'Thickness', 'Height'],
+        positiveKeys: ['Thickness', 'Height'],
+        pointArity: { Start: 3, End: 3 },
+        axisPair: ['Start', 'End'],
+        useWhen: 'Create a wall from a start/end axis on the current storey.',
+    },
+    addIfcSlab: {
+        taskTags: ['create', 'repair'],
+        placement: 'storey-relative',
+        requiredKeys: ['Position', 'Thickness'],
+        anyOfKeys: [['Profile'], ['Width', 'Depth']],
+        positiveKeys: ['Thickness', 'Width', 'Depth'],
+        pointArity: { Position: 3 },
+        customValidationId: 'slab-shape',
+        useWhen: 'Create a slab from a rectangular footprint or a 2D point-array profile.',
+    },
+    addIfcColumn: {
+        taskTags: ['create', 'repair'],
+        placement: 'storey-relative',
+        requiredKeys: ['Position', 'Width', 'Depth', 'Height'],
+        positiveKeys: ['Width', 'Depth', 'Height'],
+        pointArity: { Position: 3 },
+        useWhen: 'Create a vertical column from a base position and dimensions.',
+    },
+    addIfcBeam: {
+        taskTags: ['create', 'repair'],
+        placement: 'storey-relative',
+        requiredKeys: ['Start', 'End', 'Width', 'Height'],
+        positiveKeys: ['Width', 'Height'],
+        pointArity: { Start: 3, End: 3 },
+        axisPair: ['Start', 'End'],
+        useWhen: 'Create a beam from an axis on the current storey.',
+    },
+    addIfcMember: {
+        taskTags: ['create', 'repair'],
+        placement: 'world',
+        requiredKeys: ['Start', 'End', 'Width', 'Height'],
+        positiveKeys: ['Width', 'Height'],
+        pointArity: { Start: 3, End: 3 },
+        axisPair: ['Start', 'End'],
+        useWhen: 'Create mullions, braces, or facade members with explicit world coordinates.',
+        cautions: [
+            'Inside storey loops, include the current storey elevation in Start/End Z for facade members.',
+        ],
+    },
+    addIfcPlate: {
+        taskTags: ['create', 'repair'],
+        placement: 'world',
+        requiredKeys: ['Position', 'Width', 'Depth', 'Thickness'],
+        positiveKeys: ['Width', 'Depth', 'Thickness'],
+        pointArity: { Position: 3 },
+        forbiddenKeys: [
+            { key: 'Height', message: '`bim.create.addIfcPlate(...)` uses `Depth` and `Thickness`, not `Height`.' },
+            { key: 'Start', message: '`bim.create.addIfcPlate(...)` uses `Position`, not `Start`/`End`.' },
+            { key: 'End', message: '`bim.create.addIfcPlate(...)` uses `Position`, not `Start`/`End`.' },
+        ],
+        useWhen: 'Create thin world-placement panels or facade plates from a base point.',
+        cautions: [
+            'Facade plates repeated by storey usually need absolute Z = elevation + localOffset.',
+        ],
+    },
+    addIfcCurtainWall: {
+        taskTags: ['create', 'repair'],
+        placement: 'world',
+        requiredKeys: ['Start', 'End', 'Height'],
+        positiveKeys: ['Height', 'Thickness'],
+        pointArity: { Start: 3, End: 3 },
+        axisPair: ['Start', 'End'],
+        useWhen: 'Create a world-placement curtain wall segment between two points.',
+        cautions: [
+            'Inside storey loops, include the current storey elevation in Start/End Z.',
+        ],
+    },
+    addIfcRailing: {
+        taskTags: ['create', 'repair'],
+        placement: 'world',
+        requiredKeys: ['Start', 'End', 'Height'],
+        positiveKeys: ['Height', 'Width'],
+        pointArity: { Start: 3, End: 3 },
+        axisPair: ['Start', 'End'],
+        useWhen: 'Create a world-placement railing along an axis.',
+    },
+    addIfcStair: {
+        taskTags: ['create', 'repair'],
+        placement: 'storey-relative',
+        requiredKeys: ['Position', 'NumberOfRisers', 'RiserHeight', 'TreadLength', 'Width'],
+        positiveKeys: ['NumberOfRisers', 'RiserHeight', 'TreadLength', 'Width'],
+        pointArity: { Position: 3 },
+        useWhen: 'Create a stair from a base position and riser/tread definition.',
+    },
+    addIfcRoof: {
+        taskTags: ['create', 'repair'],
+        placement: 'storey-relative',
+        requiredKeys: ['Position', 'Width', 'Depth', 'Thickness'],
+        positiveKeys: ['Width', 'Depth', 'Thickness', 'Slope'],
+        pointArity: { Position: 3 },
+        forbiddenKeys: [
+            { key: 'Profile', message: '`bim.create.addIfcRoof(...)` does not support `Profile`. Use `Position`, `Width`, `Depth`, `Thickness`, and optional `Slope`.' },
+            { key: 'ExtrusionHeight', message: '`bim.create.addIfcRoof(...)` uses `Depth`, not `ExtrusionHeight`.' },
+            { key: 'Height', message: '`bim.create.addIfcRoof(...)` uses `Thickness` and `Depth`, not `Height`.' },
+            { key: 'Overhang', message: '`bim.create.addIfcRoof(...)` does not support `Overhang`. Use `addIfcGableRoof(...)` for a house-style roof with pitch and overhang.' },
+        ],
+        customValidationId: 'roof-shape',
+        useWhen: 'Create flat or mono-pitch roof slabs only.',
+        cautions: [
+            'Slope is in radians.',
+            'Use addIfcGableRoof for house, pitched-roof, or gable-roof requests.',
+        ],
+    },
+    addIfcGableRoof: {
+        taskTags: ['create', 'repair'],
+        placement: 'storey-relative',
+        requiredKeys: ['Position', 'Width', 'Depth', 'Thickness', 'Slope'],
+        positiveKeys: ['Width', 'Depth', 'Thickness', 'Slope'],
+        pointArity: { Position: 3 },
+        forbiddenKeys: [
+            { key: 'Profile', message: '`bim.create.addIfcGableRoof(...)` does not support `Profile`. Use `Position`, `Width`, `Depth`, `Thickness`, `Slope`, and optional `Overhang`.' },
+            { key: 'ExtrusionHeight', message: '`bim.create.addIfcGableRoof(...)` uses `Thickness`, not `ExtrusionHeight`.' },
+            { key: 'Height', message: '`bim.create.addIfcGableRoof(...)` uses `Thickness` for roof thickness and derives ridge height from `Slope`.' },
+        ],
+        customValidationId: 'roof-shape',
+        useWhen: 'Create standard dual-pitch house roofs.',
+        cautions: [
+            'Slope is in radians.',
+        ],
+    },
+    addIfcWallDoor: {
+        taskTags: ['create', 'repair'],
+        placement: 'wall-local',
+        requiredKeys: ['Position', 'Width', 'Height'],
+        positiveKeys: ['Width', 'Height', 'Thickness'],
+        pointArity: { Position: 3 },
+        forbiddenKeys: [
+            { key: 'Start', message: '`bim.create.addIfcWallDoor(...)` uses wall-local `Position`, not `Start`/`End`.' },
+            { key: 'End', message: '`bim.create.addIfcWallDoor(...)` uses wall-local `Position`, not `Start`/`End`.' },
+            { key: 'Rotation', message: '`bim.create.addIfcWallDoor(...)` auto-aligns to the host wall. Do not pass `Rotation`.' },
+            { key: 'Direction', message: '`bim.create.addIfcWallDoor(...)` auto-aligns to the host wall. Do not pass `Direction`.' },
+            { key: 'Axis', message: '`bim.create.addIfcWallDoor(...)` auto-aligns to the host wall. Do not pass `Axis`.' },
+            { key: 'RefDirection', message: '`bim.create.addIfcWallDoor(...)` auto-aligns to the host wall. Do not pass `RefDirection`.' },
+            { key: 'Placement', message: '`bim.create.addIfcWallDoor(...)` uses wall-local `Position`, not `Placement`.' },
+        ],
+        useWhen: 'Create a wall-hosted door aligned to a host wall.',
+    },
+    addIfcWallWindow: {
+        taskTags: ['create', 'repair'],
+        placement: 'wall-local',
+        requiredKeys: ['Position', 'Width', 'Height'],
+        positiveKeys: ['Width', 'Height', 'Thickness'],
+        pointArity: { Position: 3 },
+        forbiddenKeys: [
+            { key: 'Start', message: '`bim.create.addIfcWallWindow(...)` uses wall-local `Position`, not `Start`/`End`.' },
+            { key: 'End', message: '`bim.create.addIfcWallWindow(...)` uses wall-local `Position`, not `Start`/`End`.' },
+            { key: 'Rotation', message: '`bim.create.addIfcWallWindow(...)` auto-aligns to the host wall. Do not pass `Rotation`.' },
+            { key: 'Direction', message: '`bim.create.addIfcWallWindow(...)` auto-aligns to the host wall. Do not pass `Direction`.' },
+            { key: 'Axis', message: '`bim.create.addIfcWallWindow(...)` auto-aligns to the host wall. Do not pass `Axis`.' },
+            { key: 'RefDirection', message: '`bim.create.addIfcWallWindow(...)` auto-aligns to the host wall. Do not pass `RefDirection`.' },
+            { key: 'Placement', message: '`bim.create.addIfcWallWindow(...)` uses wall-local `Position`, not `Placement`.' },
+        ],
+        useWhen: 'Create a wall-hosted window aligned to a host wall.',
+    },
+    addIfcDoor: {
+        taskTags: ['create', 'repair'],
+        placement: 'world',
+        requiredKeys: ['Position', 'Width', 'Height'],
+        positiveKeys: ['Width', 'Height', 'Thickness'],
+        pointArity: { Position: 3 },
+        forbiddenKeys: [
+            { key: 'Start', message: '`bim.create.addIfcDoor(...)` uses `Position`, not `Start`/`End`.' },
+            { key: 'End', message: '`bim.create.addIfcDoor(...)` uses `Position`, not `Start`/`End`.' },
+            { key: 'Direction', message: '`bim.create.addIfcDoor(...)` does not support wall-axis rotation. It creates a world-aligned standalone door element.' },
+            { key: 'Rotation', message: '`bim.create.addIfcDoor(...)` does not support rotation. For wall-hosted inserts, use `bim.create.addIfcWallDoor(...)` or wall `Openings`.' },
+            { key: 'Axis', message: '`bim.create.addIfcDoor(...)` does not accept `Axis`. It is not a generic placement API.' },
+            { key: 'RefDirection', message: '`bim.create.addIfcDoor(...)` does not accept `RefDirection`. It is not auto-aligned to wall direction.' },
+            { key: 'Placement', message: '`bim.create.addIfcDoor(...)` uses `Position`, not `Placement`.' },
+        ],
+        useWhen: 'Create a standalone world-aligned door element.',
+        cautions: [
+            'For wall-hosted inserts, use addIfcWallDoor or wall Openings instead.',
+        ],
+    },
+    addIfcWindow: {
+        taskTags: ['create', 'repair'],
+        placement: 'world',
+        requiredKeys: ['Position', 'Width', 'Height'],
+        positiveKeys: ['Width', 'Height', 'Thickness'],
+        pointArity: { Position: 3 },
+        forbiddenKeys: [
+            { key: 'Start', message: '`bim.create.addIfcWindow(...)` uses `Position`, not `Start`/`End`.' },
+            { key: 'End', message: '`bim.create.addIfcWindow(...)` uses `Position`, not `Start`/`End`.' },
+            { key: 'Direction', message: '`bim.create.addIfcWindow(...)` does not support wall-axis rotation. It creates a world-aligned standalone window element.' },
+            { key: 'Rotation', message: '`bim.create.addIfcWindow(...)` does not support rotation. For wall-hosted inserts, use `bim.create.addIfcWallWindow(...)` or wall `Openings`.' },
+            { key: 'Axis', message: '`bim.create.addIfcWindow(...)` does not accept `Axis`. It is not a generic placement API.' },
+            { key: 'RefDirection', message: '`bim.create.addIfcWindow(...)` does not accept `RefDirection`. It is not auto-aligned to wall direction.' },
+            { key: 'Placement', message: '`bim.create.addIfcWindow(...)` uses `Position`, not `Placement`.' },
+        ],
+        useWhen: 'Create a standalone world-aligned window element.',
+        cautions: [
+            'For wall-hosted inserts, use addIfcWallWindow or wall Openings instead.',
+        ],
+    },
+    addElement: {
+        taskTags: ['create', 'repair'],
+        placement: 'explicit-placement',
+        requiredKeys: ['IfcType', 'Placement', 'Profile', 'Depth'],
+        positiveKeys: ['Depth'],
+        customValidationId: 'generic-element',
+        useWhen: 'Create advanced IFC entities only when no dedicated helper exists.',
+    },
+    addAxisElement: {
+        taskTags: ['create', 'repair'],
+        placement: 'world',
+        requiredKeys: ['IfcType', 'Start', 'End', 'Profile'],
+        pointArity: { Start: 3, End: 3 },
+        axisPair: ['Start', 'End'],
+        customValidationId: 'axis-element',
+        useWhen: 'Create advanced axis-based IFC entities when no dedicated helper exists.',
+    },
+};
+/**
+ * Build all bim.create method schemas by discovering public methods
+ * on IfcCreator.prototype. New methods are automatically exposed.
+ */
+function buildCreateMethods() {
+    const methods = [];
+    // ── Special: project (creates IfcCreator, returns handle) ──
+    methods.push({
+        name: 'project',
+        doc: 'Create a new IFC project. Returns a creator handle (number).',
+        args: ['dump'],
+        paramNames: ['params'],
+        tsParamTypes: ['{ Name?: string; Description?: string; Schema?: string; LengthUnit?: string; Author?: string; Organization?: string }'],
+        tsReturn: 'number',
+        call: (_sdk, args, context) => {
+            const params = (args[0] ?? {});
+            const creator = new IfcCreator(params);
+            return creatorRegistry.registerForSession(context.sandboxSessionId, creator);
+        },
+        returns: 'value',
+        llmSemantics: CREATE_METHOD_SEMANTICS.project,
+    });
+    // ── Special: toIfc (finalizes + cleans up handle) ──
+    methods.push({
+        name: 'toIfc',
+        doc: 'Generate the IFC STEP file content. Returns { content, entities, stats }.',
+        args: ['number'],
+        paramNames: ['handle'],
+        tsReturn: '{ content: string; entities: Array<{ expressId: number; type: string; Name?: string }>; stats: { entityCount: number; fileSize: number } }',
+        call: (_sdk, args, context) => {
+            const handle = args[0];
+            try {
+                const creator = creatorRegistry.getForSession(context.sandboxSessionId, handle);
+                return creator.toIfc();
+            }
+            finally {
+                creatorRegistry.removeForSession(context.sandboxSessionId, handle);
+            }
+        },
+        returns: 'value',
+        llmSemantics: CREATE_METHOD_SEMANTICS.toIfc,
+    });
+    // ── Special: setColor (unique signature: handle, elementId, name, rgb) ──
+    methods.push({
+        name: 'setColor',
+        doc: 'Assign a named colour to an element. Call before toIfc().',
+        args: ['number', 'number', 'string', 'dump'],
+        paramNames: ['handle', 'elementId', 'name', 'rgb'],
+        tsReturn: 'void',
+        call: (_sdk, args, context) => {
+            const creator = creatorRegistry.getForSession(context.sandboxSessionId, args[0]);
+            creator.setColor(args[1], args[2], args[3]);
+        },
+        returns: 'void',
+        llmSemantics: CREATE_METHOD_SEMANTICS.setColor,
+    });
+    // ── Auto-discover all other public methods from IfcCreator.prototype ──
+    const proto = IfcCreator.prototype;
+    const methodNames = Object.getOwnPropertyNames(proto)
+        .filter(name => typeof proto[name] === 'function' && ALLOWED_METHODS.has(name))
+        .sort();
+    for (const name of methodNames) {
+        const pattern = classifyMethod(name, proto[name]);
+        if (pattern === 'special')
+            continue; // already handled above
+        switch (pattern) {
+            case 'storey-params':
+                // addIfcBuildingStorey takes (params) — 1 arg after handle
+                if (name === 'addIfcBuildingStorey') {
+                    methods.push({
+                        name,
+                        doc: methodDoc(name),
+                        args: ['number', 'dump'],
+                        paramNames: ['handle', 'params'],
+                        tsReturn: 'number',
+                        call: (_sdk, args, context) => {
+                            const creator = creatorRegistry.getForSession(context.sandboxSessionId, args[0]);
+                            return creator[name](args[1]);
+                        },
+                        returns: 'value',
+                        llmSemantics: CREATE_METHOD_SEMANTICS[name],
+                    });
+                }
+                else {
+                    // Standard: (storeyId, params) — 2 args after handle
+                    methods.push({
+                        name,
+                        doc: methodDoc(name),
+                        args: ['number', 'number', 'dump'],
+                        paramNames: ['handle', 'storeyId', 'params'],
+                        tsReturn: 'number',
+                        call: (_sdk, args, context) => {
+                            const creator = creatorRegistry.getForSession(context.sandboxSessionId, args[0]);
+                            return creator[name](args[1], args[2]);
+                        },
+                        returns: 'value',
+                        llmSemantics: CREATE_METHOD_SEMANTICS[name],
+                    });
+                }
+                break;
+            case 'element-params':
+                // (elementId, def) — 2 args after handle, may return number or void
+                methods.push({
+                    name,
+                    doc: methodDoc(name),
+                    args: ['number', 'number', 'dump'],
+                    paramNames: ['handle', name === 'addIfcWallDoor' || name === 'addIfcWallWindow' ? 'wallId' : 'elementId', 'params'],
+                    tsReturn: name === 'addIfcMaterial' ? 'void' : 'number',
+                    call: (_sdk, args, context) => {
+                        const creator = creatorRegistry.getForSession(context.sandboxSessionId, args[0]);
+                        return creator[name](args[1], args[2]);
+                    },
+                    returns: name === 'addIfcMaterial' ? 'void' : 'value',
+                    llmSemantics: CREATE_METHOD_SEMANTICS[name],
+                });
+                break;
+            case 'single-dump':
+                methods.push({
+                    name,
+                    doc: methodDoc(name),
+                    args: ['number', 'dump'],
+                    paramNames: ['handle', 'profile'],
+                    tsReturn: 'number',
+                    call: (_sdk, args, context) => {
+                        const creator = creatorRegistry.getForSession(context.sandboxSessionId, args[0]);
+                        return creator[name](args[1]);
+                    },
+                    returns: 'value',
+                    llmSemantics: CREATE_METHOD_SEMANTICS[name],
+                });
+                break;
+            case 'no-args':
+                methods.push({
+                    name,
+                    doc: methodDoc(name),
+                    args: ['number'],
+                    paramNames: ['handle'],
+                    tsReturn: 'number',
+                    call: (_sdk, args, context) => {
+                        const creator = creatorRegistry.getForSession(context.sandboxSessionId, args[0]);
+                        return creator[name]();
+                    },
+                    returns: 'value',
+                    llmSemantics: CREATE_METHOD_SEMANTICS[name],
+                });
+                break;
+        }
+    }
+    return methods;
+}
 // ============================================================================
 // Schema Definitions
 // ============================================================================
@@ -151,6 +652,26 @@ export const NAMESPACE_SCHEMAS = [
                 },
                 returns: 'value',
             },
+            {
+                name: 'attributes',
+                doc: 'Get all named string/enum attributes for an entity',
+                args: ['dump'],
+                paramNames: ['entity'],
+                tsParamTypes: ['BimEntity'],
+                tsReturn: 'BimAttribute[]',
+                call: (sdk, args) => {
+                    const ref = toRef(args[0]);
+                    if (!ref)
+                        return [];
+                    return sdk.attributes(ref);
+                },
+                returns: 'value',
+                llmSemantics: {
+                    taskTags: ['inspect', 'repair'],
+                    inspectFirst: true,
+                    useWhen: 'Inspect raw IFC occurrence attributes before guessing metadata names.',
+                },
+            },
             {
                 name: 'properties',
                 doc: 'Get all IfcPropertySet data for an entity',
@@ -162,9 +683,22 @@ export const NAMESPACE_SCHEMAS = [
                     const ref = toRef(args[0]);
                     if (!ref)
                         return [];
-                    return sdk.properties(ref);
+                    return sdk.properties(ref).map(pset => {
+                        const mappedProperties = mapNamedProperties(pset.properties);
+                        return {
+                            name: pset.name, Name: pset.name,
+                            globalId: pset.globalId, GlobalId: pset.globalId,
+                            properties: mappedProperties,
+                            Properties: mappedProperties,
+                        };
+                    });
                 },
                 returns: 'value',
+                llmSemantics: {
+                    taskTags: ['inspect', 'repair'],
+                    inspectFirst: true,
+                    useWhen: 'Inspect all property sets on an occurrence before guessing individual property names.',
+                },
             },
             {
                 name: 'quantities',
@@ -177,9 +711,314 @@ export const NAMESPACE_SCHEMAS = [
                     const ref = toRef(args[0]);
                     if (!ref)
                         return [];
-                    return sdk.quantities(ref);
+                    return sdk.quantities(ref).map(qset => {
+                        const mappedQuantities = mapNamedProperties(qset.quantities);
+                        return {
+                            name: qset.name, Name: qset.name,
+                            quantities: mappedQuantities,
+                            Quantities: mappedQuantities,
+                        };
+                    });
                 },
                 returns: 'value',
+                llmSemantics: {
+                    taskTags: ['inspect', 'repair'],
+                    inspectFirst: true,
+                    useWhen: 'Inspect all quantity sets on an occurrence.',
+                },
+            },
+            {
+                name: 'property',
+                doc: 'Get a single property value from an entity',
+                args: ['dump', 'string', 'string'],
+                paramNames: ['entity', 'psetName', 'propName'],
+                tsParamTypes: ['BimEntity'],
+                tsReturn: 'string | number | boolean | null',
+                call: (sdk, args) => {
+                    const ref = toRef(args[0]);
+                    if (!ref)
+                        return null;
+                    return sdk.property(ref, args[1], args[2]);
+                },
+                returns: 'value',
+                llmSemantics: {
+                    taskTags: ['inspect', 'repair'],
+                    inspectFirst: true,
+                    useWhen: 'Read one known property when you already know the exact property-set and property names.',
+                },
+            },
+            {
+                name: 'classifications',
+                doc: 'Get classification references for an entity',
+                args: ['dump'],
+                paramNames: ['entity'],
+                tsParamTypes: ['BimEntity'],
+                tsReturn: 'BimClassification[]',
+                call: (sdk, args) => {
+                    const ref = toRef(args[0]);
+                    if (!ref)
+                        return [];
+                    return sdk.classifications(ref);
+                },
+                returns: 'value',
+                llmSemantics: {
+                    taskTags: ['inspect', 'repair'],
+                    inspectFirst: true,
+                    useWhen: 'Read relationship-based classification references.',
+                    cautions: ['Prefer this over guessing ad-hoc classification property names.'],
+                },
+            },
+            {
+                name: 'materials',
+                doc: 'Get material assignment for an entity',
+                args: ['dump'],
+                paramNames: ['entity'],
+                tsParamTypes: ['BimEntity'],
+                tsReturn: 'BimMaterial | null',
+                call: (sdk, args) => {
+                    const ref = toRef(args[0]);
+                    if (!ref)
+                        return null;
+                    return sdk.materials(ref);
+                },
+                returns: 'value',
+                llmSemantics: {
+                    taskTags: ['inspect', 'repair'],
+                    inspectFirst: true,
+                    useWhen: 'Read assigned material data for an entity.',
+                    cautions: ['Prefer this over querying Pset_MaterialCommon or Material.Name as ordinary property sets.'],
+                },
+            },
+            {
+                name: 'typeProperties',
+                doc: 'Get type-level property sets for an entity',
+                args: ['dump'],
+                paramNames: ['entity'],
+                tsParamTypes: ['BimEntity'],
+                tsReturn: 'BimTypeProperties | null',
+                call: (sdk, args) => {
+                    const ref = toRef(args[0]);
+                    if (!ref)
+                        return null;
+                    return sdk.typeProperties(ref);
+                },
+                returns: 'value',
+                llmSemantics: {
+                    taskTags: ['inspect', 'repair'],
+                    inspectFirst: true,
+                    useWhen: 'Inspect type-level properties when occurrence-level property sets are missing expected data.',
+                },
+            },
+            {
+                name: 'documents',
+                doc: 'Get linked document references for an entity',
+                args: ['dump'],
+                paramNames: ['entity'],
+                tsParamTypes: ['BimEntity'],
+                tsReturn: 'BimDocument[]',
+                call: (sdk, args) => {
+                    const ref = toRef(args[0]);
+                    if (!ref)
+                        return [];
+                    return sdk.documents(ref);
+                },
+                returns: 'value',
+                llmSemantics: {
+                    taskTags: ['inspect', 'repair'],
+                    inspectFirst: true,
+                    useWhen: 'Inspect linked document references and external documentation.',
+                },
+            },
+            {
+                name: 'relationships',
+                doc: 'Get structural relationship summary for an entity',
+                args: ['dump'],
+                paramNames: ['entity'],
+                tsParamTypes: ['BimEntity'],
+                tsReturn: 'BimRelationships',
+                call: (sdk, args) => {
+                    const ref = toRef(args[0]);
+                    if (!ref)
+                        return { voids: [], fills: [], groups: [], connections: [] };
+                    return sdk.relationships(ref);
+                },
+                returns: 'value',
+                llmSemantics: {
+                    taskTags: ['inspect', 'repair'],
+                    inspectFirst: true,
+                    useWhen: 'Inspect structural and semantic relationships such as voids, fills, groups, and connections.',
+                },
+            },
+            {
+                name: 'quantity',
+                doc: 'Get a single quantity value from an entity',
+                args: ['dump', 'string', 'string'],
+                paramNames: ['entity', 'qsetName', 'quantityName'],
+                tsParamTypes: ['BimEntity'],
+                tsReturn: 'number | null',
+                call: (sdk, args) => {
+                    const ref = toRef(args[0]);
+                    if (!ref)
+                        return null;
+                    return sdk.quantity(ref, args[1], args[2]);
+                },
+                returns: 'value',
+            },
+            {
+                name: 'related',
+                doc: 'Get related entities by IFC relationship type',
+                args: ['dump', 'string', 'string'],
+                paramNames: ['entity', 'relType', 'direction'],
+                tsParamTypes: ['BimEntity', undefined, "'forward' | 'inverse'"],
+                tsReturn: 'BimEntity[]',
+                call: (sdk, args) => {
+                    const ref = toRef(args[0]);
+                    if (!ref)
+                        return [];
+                    return sdk.related(ref, args[1], args[2]).map(withAliases);
+                },
+                returns: 'value',
+                llmSemantics: {
+                    taskTags: ['inspect', 'repair'],
+                    inspectFirst: true,
+                    useWhen: 'Traverse a known IFC relationship type in forward or inverse direction.',
+                },
+            },
+            {
+                name: 'containedIn',
+                doc: 'Get the spatial container of an entity',
+                args: ['dump'],
+                paramNames: ['entity'],
+                tsParamTypes: ['BimEntity'],
+                tsReturn: 'BimEntity | null',
+                call: (sdk, args) => {
+                    const ref = toRef(args[0]);
+                    if (!ref)
+                        return null;
+                    const entity = sdk.containedIn(ref);
+                    return entity ? withAliases(entity) : null;
+                },
+                returns: 'value',
+            },
+            {
+                name: 'contains',
+                doc: 'Get entities contained in a spatial container',
+                args: ['dump'],
+                paramNames: ['entity'],
+                tsParamTypes: ['BimEntity'],
+                tsReturn: 'BimEntity[]',
+                call: (sdk, args) => {
+                    const ref = toRef(args[0]);
+                    if (!ref)
+                        return [];
+                    return sdk.contains(ref).map(withAliases);
+                },
+                returns: 'value',
+            },
+            {
+                name: 'decomposedBy',
+                doc: 'Get the parent aggregate of an entity',
+                args: ['dump'],
+                paramNames: ['entity'],
+                tsParamTypes: ['BimEntity'],
+                tsReturn: 'BimEntity | null',
+                call: (sdk, args) => {
+                    const ref = toRef(args[0]);
+                    if (!ref)
+                        return null;
+                    const entity = sdk.decomposedBy(ref);
+                    return entity ? withAliases(entity) : null;
+                },
+                returns: 'value',
+            },
+            {
+                name: 'decomposes',
+                doc: 'Get aggregated children of an entity',
+                args: ['dump'],
+                paramNames: ['entity'],
+                tsParamTypes: ['BimEntity'],
+                tsReturn: 'BimEntity[]',
+                call: (sdk, args) => {
+                    const ref = toRef(args[0]);
+                    if (!ref)
+                        return [];
+                    return sdk.decomposes(ref).map(withAliases);
+                },
+                returns: 'value',
+            },
+            {
+                name: 'storey',
+                doc: 'Get the containing building storey of an entity',
+                args: ['dump'],
+                paramNames: ['entity'],
+                tsParamTypes: ['BimEntity'],
+                tsReturn: 'BimEntity | null',
+                call: (sdk, args) => {
+                    const ref = toRef(args[0]);
+                    if (!ref)
+                        return null;
+                    const entity = sdk.storey(ref);
+                    return entity ? withAliases(entity) : null;
+                },
+                returns: 'value',
+                llmSemantics: {
+                    taskTags: ['inspect', 'repair'],
+                    inspectFirst: true,
+                    useWhen: 'Resolve which building storey currently contains an entity.',
+                },
+            },
+            {
+                name: 'path',
+                doc: 'Get the spatial/aggregation path from project to entity',
+                args: ['dump'],
+                paramNames: ['entity'],
+                tsParamTypes: ['BimEntity'],
+                tsReturn: 'BimEntity[]',
+                call: (sdk, args) => {
+                    const ref = toRef(args[0]);
+                    if (!ref)
+                        return [];
+                    return sdk.path(ref).map(withAliases);
+                },
+                returns: 'value',
+                llmSemantics: {
+                    taskTags: ['inspect', 'repair'],
+                    inspectFirst: true,
+                    useWhen: 'Inspect the full project-to-entity spatial path before generating hierarchy-aware edits.',
+                },
+            },
+            {
+                name: 'storeys',
+                doc: 'List all building storeys',
+                args: [],
+                tsReturn: 'BimEntity[]',
+                call: (sdk) => {
+                    return sdk.storeys().map(withAliases);
+                },
+                returns: 'value',
+                llmSemantics: {
+                    taskTags: ['inspect', 'repair'],
+                    inspectFirst: true,
+                    useWhen: 'List all building storeys and use their actual names/elevations as generation targets.',
+                },
+            },
+            {
+                name: 'selection',
+                doc: 'Get the current viewer selection as entities',
+                args: [],
+                tsReturn: 'BimEntity[]',
+                call: (sdk) => {
+                    return sdk.viewer.getSelection()
+                        .map((ref) => sdk.entity(ref))
+                        .filter((entity) => Boolean(entity))
+                        .map(withAliases);
+                },
+                returns: 'value',
+                llmSemantics: {
+                    taskTags: ['inspect', 'repair'],
+                    inspectFirst: true,
+                    useWhen: 'Inspect what the user currently selected in the viewer before proposing targeted edits or analysis.',
+                },
             },
         ],
     },
@@ -296,11 +1135,29 @@ export const NAMESPACE_SCHEMAS = [
         methods: [
             {
                 name: 'setProperty',
-                doc: 'Set a property value',
+                doc: 'Set an IfcPropertySet or quantity value (not a root IFC attribute)',
                 args: ['dump', 'string', 'string', 'dump'],
                 paramNames: ['entity', 'psetName', 'propName', 'value'],
                 call: (sdk, args) => {
-                    sdk.mutate.setProperty(args[0], args[1], args[2], args[3]);
+                    const ref = toRef(args[0]);
+                    if (!ref) {
+                        throw new Error('bim.mutate.setProperty: invalid entity reference');
+                    }
+                    sdk.mutate.setProperty(ref, args[1], args[2], args[3]);
+                },
+                returns: 'void',
+            },
+            {
+                name: 'setAttribute',
+                doc: 'Set a root IFC attribute such as Name, Description, ObjectType, or Tag',
+                args: ['dump', 'string', 'string'],
+                paramNames: ['entity', 'attrName', 'value'],
+                call: (sdk, args) => {
+                    const ref = toRef(args[0]);
+                    if (!ref) {
+                        throw new Error('bim.mutate.setAttribute: invalid entity reference');
+                    }
+                    sdk.mutate.setAttribute(ref, args[1], args[2]);
                 },
                 returns: 'void',
             },
@@ -310,7 +1167,11 @@ export const NAMESPACE_SCHEMAS = [
                 args: ['dump', 'string', 'string'],
                 paramNames: ['entity', 'psetName', 'propName'],
                 call: (sdk, args) => {
-                    sdk.mutate.deleteProperty(args[0], args[1], args[2]);
+                    const ref = toRef(args[0]);
+                    if (!ref) {
+                        throw new Error('bim.mutate.deleteProperty: invalid entity reference');
+                    }
+                    sdk.mutate.deleteProperty(ref, args[1], args[2]);
                 },
                 returns: 'void',
             },
@@ -356,190 +1217,68 @@ export const NAMESPACE_SCHEMAS = [
         ],
     },
     // ── bim.create ─────────────────────────────────────────────
+    //
+    // Auto-discovered from IfcCreator.prototype at module load.
+    // Adding a new public method to IfcCreator automatically exposes it
+    // in the sandbox — no manual bridge wiring needed.
+    //
     {
         name: 'create',
         doc: 'IFC creation from scratch',
         permission: 'export', // reuses export permission — creation produces files
+        methods: buildCreateMethods(),
+    },
+    // ── bim.export ─────────────────────────────────────────────
+    {
+        name: 'files',
+        doc: 'Uploaded file attachments',
+        permission: 'files',
         methods: [
             {
-                name: 'project',
-                doc: 'Create a new IFC project. Returns a creator handle (number).',
-                args: ['dump'],
-                paramNames: ['params'],
-                tsParamTypes: ['{ Name?: string; Description?: string; Schema?: string; LengthUnit?: string; Author?: string; Organization?: string }'],
-                tsReturn: 'number',
-                call: (_sdk, args) => {
-                    const params = (args[0] ?? {});
-                    const creator = new IfcCreator(params);
-                    return creatorRegistry.register(creator);
-                },
-                returns: 'value',
-            },
-            {
-                name: 'addIfcBuildingStorey',
-                doc: 'Add a building storey. Returns storey expressId.',
-                args: ['number', 'dump'],
-                paramNames: ['handle', 'params'],
-                tsParamTypes: [undefined, '{ Name?: string; Description?: string; Elevation: number }'],
-                tsReturn: 'number',
-                call: (_sdk, args) => {
-                    const creator = creatorRegistry.get(args[0]);
-                    return creator.addIfcBuildingStorey(args[1]);
-                },
-                returns: 'value',
-            },
-            {
-                name: 'addIfcWall',
-                doc: 'Add a wall to a storey. Returns wall expressId.',
-                args: ['number', 'number', 'dump'],
-                paramNames: ['handle', 'storeyId', 'params'],
-                tsParamTypes: [undefined, undefined, '{ Start: [number,number,number]; End: [number,number,number]; Thickness: number; Height: number; Name?: string; Openings?: Array<{ Width: number; Height: number; Position: [number,number,number]; Name?: string }> }'],
-                tsReturn: 'number',
-                call: (_sdk, args) => {
-                    const creator = creatorRegistry.get(args[0]);
-                    return creator.addIfcWall(args[1], args[2]);
-                },
-                returns: 'value',
-            },
-            {
-                name: 'addIfcSlab',
-                doc: 'Add a slab to a storey. Returns slab expressId.',
-                args: ['number', 'number', 'dump'],
-                paramNames: ['handle', 'storeyId', 'params'],
-                tsParamTypes: [undefined, undefined, '{ Position: [number,number,number]; Thickness: number; Width?: number; Depth?: number; Profile?: [number,number][]; Name?: string; Openings?: Array<{ Width: number; Height: number; Position: [number,number,number]; Name?: string }> }'],
-                tsReturn: 'number',
-                call: (_sdk, args) => {
-                    const creator = creatorRegistry.get(args[0]);
-                    return creator.addIfcSlab(args[1], args[2]);
-                },
-                returns: 'value',
-            },
-            {
-                name: 'addIfcColumn',
-                doc: 'Add a column to a storey. Returns column expressId.',
-                args: ['number', 'number', 'dump'],
-                paramNames: ['handle', 'storeyId', 'params'],
-                tsParamTypes: [undefined, undefined, '{ Position: [number,number,number]; Width: number; Depth: number; Height: number; Name?: string }'],
-                tsReturn: 'number',
-                call: (_sdk, args) => {
-                    const creator = creatorRegistry.get(args[0]);
-                    return creator.addIfcColumn(args[1], args[2]);
-                },
-                returns: 'value',
-            },
-            {
-                name: 'addIfcBeam',
-                doc: 'Add a beam to a storey. Returns beam expressId.',
-                args: ['number', 'number', 'dump'],
-                paramNames: ['handle', 'storeyId', 'params'],
-                tsParamTypes: [undefined, undefined, '{ Start: [number,number,number]; End: [number,number,number]; Width: number; Height: number; Name?: string }'],
-                tsReturn: 'number',
-                call: (_sdk, args) => {
-                    const creator = creatorRegistry.get(args[0]);
-                    return creator.addIfcBeam(args[1], args[2]);
-                },
-                returns: 'value',
-            },
-            {
-                name: 'addIfcStair',
-                doc: 'Add a stair to a storey. Returns stair expressId.',
-                args: ['number', 'number', 'dump'],
-                paramNames: ['handle', 'storeyId', 'params'],
-                tsParamTypes: [undefined, undefined, '{ Position: [number,number,number]; NumberOfRisers: number; RiserHeight: number; TreadLength: number; Width: number; Direction?: number; Name?: string }'],
-                tsReturn: 'number',
-                call: (_sdk, args) => {
-                    const creator = creatorRegistry.get(args[0]);
-                    return creator.addIfcStair(args[1], args[2]);
-                },
+                name: 'list',
+                doc: 'List uploaded file attachments available to scripts',
+                args: [],
+                tsReturn: 'BimFileAttachment[]',
+                call: (sdk) => sdk.files.list(),
                 returns: 'value',
             },
             {
-                name: 'addIfcRoof',
-                doc: 'Add a roof to a storey. Returns roof expressId.',
-                args: ['number', 'number', 'dump'],
-                paramNames: ['handle', 'storeyId', 'params'],
-                tsParamTypes: [undefined, undefined, '{ Position: [number,number,number]; Width: number; Depth: number; Thickness: number; Slope?: number; Name?: string }'],
-                tsReturn: 'number',
-                call: (_sdk, args) => {
-                    const creator = creatorRegistry.get(args[0]);
-                    return creator.addIfcRoof(args[1], args[2]);
-                },
+                name: 'text',
+                doc: 'Get raw text content for an uploaded attachment by file name',
+                args: ['string'],
+                paramNames: ['name'],
+                tsReturn: 'string | null',
+                call: (sdk, args) => sdk.files.text(args[0]),
                 returns: 'value',
-            },
-            {
-                name: 'setColor',
-                doc: 'Assign a named colour to an element. Call before toIfc().',
-                args: ['number', 'number', 'string', 'dump'],
-                paramNames: ['handle', 'elementId', 'name', 'rgb'],
-                tsParamTypes: [undefined, undefined, undefined, '[number, number, number]'],
-                tsReturn: 'void',
-                call: (_sdk, args) => {
-                    const creator = creatorRegistry.get(args[0]);
-                    creator.setColor(args[1], args[2], args[3]);
-                },
-                returns: 'void',
-            },
-            {
-                name: 'addIfcMaterial',
-                doc: 'Assign an IFC material (simple or layered) to an element.',
-                args: ['number', 'number', 'dump'],
-                paramNames: ['handle', 'elementId', 'material'],
-                tsParamTypes: [undefined, undefined, '{ Name: string; Category?: string; Layers?: Array<{ Name: string; Thickness: number; Category?: string; IsVentilated?: boolean }> }'],
-                tsReturn: 'void',
-                call: (_sdk, args) => {
-                    const creator = creatorRegistry.get(args[0]);
-                    creator.addIfcMaterial(args[1], args[2]);
+                llmSemantics: {
+                    taskTags: ['inspect', 'modify', 'repair', 'export'],
+                    useWhen: 'Read uploaded CSV, TSV, JSON, or text attachments without using fetch().',
                 },
-                returns: 'void',
             },
             {
-                name: 'addIfcPropertySet',
-                doc: 'Attach a property set to an element. Returns pset expressId.',
-                args: ['number', 'number', 'dump'],
-                paramNames: ['handle', 'elementId', 'pset'],
-                tsParamTypes: [undefined, undefined, '{ Name: string; Properties: Array<{ Name: string; NominalValue: string | number | boolean; Type?: string }> }'],
-                tsReturn: 'number',
-                call: (_sdk, args) => {
-                    const creator = creatorRegistry.get(args[0]);
-                    return creator.addIfcPropertySet(args[1], args[2]);
-                },
+                name: 'csv',
+                doc: 'Get parsed CSV/TSV rows for an uploaded attachment by file name',
+                args: ['string'],
+                paramNames: ['name'],
+                tsReturn: 'Record<string, string>[] | null',
+                call: (sdk, args) => sdk.files.csv(args[0]),
                 returns: 'value',
-            },
-            {
-                name: 'addIfcElementQuantity',
-                doc: 'Attach element quantities to an element. Returns qset expressId.',
-                args: ['number', 'number', 'dump'],
-                paramNames: ['handle', 'elementId', 'qset'],
-                tsParamTypes: [undefined, undefined, "{ Name: string; Quantities: Array<{ Name: string; Value: number; Kind: 'IfcQuantityLength' | 'IfcQuantityArea' | 'IfcQuantityVolume' | 'IfcQuantityCount' | 'IfcQuantityWeight' }> }"],
-                tsReturn: 'number',
-                call: (_sdk, args) => {
-                    const creator = creatorRegistry.get(args[0]);
-                    return creator.addIfcElementQuantity(args[1], args[2]);
+                llmSemantics: {
+                    taskTags: ['inspect', 'modify', 'repair', 'export'],
+                    useWhen: 'Load uploaded CSV rows directly inside a script and join them against model entities.',
                 },
-                returns: 'value',
             },
             {
-                name: 'toIfc',
-                doc: 'Generate the IFC STEP file content. Returns { content, entities, stats }.',
-                args: ['number'],
-                paramNames: ['handle'],
-                tsReturn: '{ content: string; entities: Array<{ expressId: number; type: string; Name?: string }>; stats: { entityCount: number; fileSize: number } }',
-                call: (_sdk, args) => {
-                    const handle = args[0];
-                    try {
-                        const creator = creatorRegistry.get(handle);
-                        return creator.toIfc();
-                    }
-                    finally {
-                        // Always clean up the creator, even if toIfc() throws
-                        creatorRegistry.remove(handle);
-                    }
-                },
+                name: 'csvColumns',
+                doc: 'Get parsed CSV column names for an uploaded attachment by file name',
+                args: ['string'],
+                paramNames: ['name'],
+                tsReturn: 'string[]',
+                call: (sdk, args) => sdk.files.csvColumns(args[0]),
                 returns: 'value',
             },
         ],
     },
-    // ── bim.export ─────────────────────────────────────────────
     {
         name: 'export',
         doc: 'Data export',
@@ -569,6 +1308,18 @@ export const NAMESPACE_SCHEMAS = [
                 },
                 returns: 'value',
             },
+            {
+                name: 'ifc',
+                doc: 'Export entities to IFC STEP text. Pass filename to auto-download a valid .ifc file',
+                args: ['entityRefs', 'dump'],
+                paramNames: ['entities', 'options'],
+                tsParamTypes: [undefined, '{ schema?: "IFC2X3" | "IFC4" | "IFC4X3"; filename?: string; includeMutations?: boolean; visibleOnly?: boolean }'],
+                tsReturn: 'string',
+                call: (sdk, args) => {
+                    return sdk.export.ifc(args[0], args[1]);
+                },
+                returns: 'string',
+            },
             {
                 name: 'download',
                 doc: 'Trigger a browser file download with the given content',
@@ -589,21 +1340,21 @@ export const NAMESPACE_SCHEMAS = [
  * Build all schema-defined namespaces on the `bim` handle.
  * Skips namespaces whose permission is disabled.
  */
-export function buildSchemaNamespaces(vm, bimHandle, sdk, permissions) {
+export function buildSchemaNamespaces(vm, bimHandle, sdk, permissions, context) {
     for (const schema of NAMESPACE_SCHEMAS) {
         if (!permissions[schema.permission])
             continue;
-        buildNamespace(vm, bimHandle, sdk, schema);
+        buildNamespace(vm, bimHandle, sdk, schema, context);
     }
 }
-function buildNamespace(vm, bimHandle, sdk, schema) {
+function buildNamespace(vm, bimHandle, sdk, schema, context) {
     const nsHandle = vm.newObject();
     for (const method of schema.methods) {
         const fn = vm.newFunction(method.name, (...handles) => {
             // Unmarshal arguments
             const nativeArgs = unmarshalArgs(vm, handles, method.args);
             // Call the SDK
-            const result = method.call(sdk, nativeArgs);
+            const result = method.call(sdk, nativeArgs, context);
             // Marshal return value
             return marshalReturn(vm, result, method.returns);
         });
@@ -613,6 +1364,9 @@ function buildNamespace(vm, bimHandle, sdk, schema) {
     vm.setProp(bimHandle, schema.name, nsHandle);
     nsHandle.dispose();
 }
+export function disposeSchemaNamespaceSession(context) {
+    creatorRegistry.removeSession(context.sandboxSessionId);
+}
 /** Unmarshal QuickJS handles to native JS values based on arg schema */
 function unmarshalArgs(vm, handles, argTypes) {
     const result = [];