@pascal-app/mcp 1.0.3 → 1.0.5

package/dist/tools/door-clearance.js

@@ -1,334 +0,0 @@
-/**
- * Door access keep-outs for MCP layout tools.
- *
- * Furniture that overlaps a door clear zone is reported as blocking the door.
- * Used by furnish_room (skip placements) and verify_scene (layout issues).
- *
- * See docs/layout-clearance-error-log.md for pitfalls (levels, gap sign, scale).
- */
-import { getScaledDimensions } from '@pascal-app/core/schema';
-import { wallLength } from './geometry.js';
-/** Plan depth (m) cleared on each side of the wall face through the opening. */
-export const DEFAULT_DOOR_CLEAR_DEPTH = 0.65;
-/** Extra half-width (m) beyond the door leaf along the wall. */
-export const DEFAULT_DOOR_SIDE_PAD = 0.05;
-/**
- * True when A and B come closer than `gap` meters (including penetration).
- * `gap` is the **minimum free space required** between boxes:
- * expand each box by gap/2, then test intersection.
- */
-export function aabbsOverlap(a, b, gap = 0) {
-    const g = gap;
-    return a.maxX + g > b.minX && a.minX - g < b.maxX && a.maxZ + g > b.minZ && a.minZ - g < b.maxZ;
-}
-/**
- * Walk parentId chain to the enclosing level id (pure; no bridge required).
- */
-export function resolveNodeLevelId(nodeId, byId) {
-    let current = byId.get(nodeId);
-    const seen = new Set();
-    while (current) {
-        if (seen.has(current.id))
-            return null;
-        seen.add(current.id);
-        if (current.type === 'level')
-            return current.id;
-        const parentId = current.parentId;
-        if (parentId && byId.has(parentId)) {
-            current = byId.get(parentId);
-            continue;
-        }
-        current = findParentByChildren(current.id, byId);
-    }
-    return null;
-}
-function findParentByChildren(nodeId, byId) {
-    for (const candidate of byId.values()) {
-        if (!('children' in candidate) || !Array.isArray(candidate.children))
-            continue;
-        const containsNode = candidate.children.some((child) => {
-            if (typeof child === 'string')
-                return child === nodeId;
-            return (child !== null &&
-                typeof child === 'object' &&
-                'id' in child &&
-                child.id === nodeId);
-        });
-        if (containsNode)
-            return candidate;
-    }
-    return undefined;
-}
-/**
- * Axis-aligned item footprint in plan (x/z), rotation-aware.
- * Prefer scaled dimensions when the node is available.
- */
-export function itemPlanAabb(position, dimensions, rotationYRad = 0) {
-    const x = position[0] ?? 0;
-    const z = position[2] ?? 0;
-    const [w = 1, , d = 1] = dimensions ?? [1, 1, 1];
-    const cos = Math.abs(Math.cos(rotationYRad));
-    const sin = Math.abs(Math.sin(rotationYRad));
-    const halfW = (w * cos + d * sin) / 2;
-    const halfD = (w * sin + d * cos) / 2;
-    return {
-        minX: x - halfW,
-        maxX: x + halfW,
-        minZ: z - halfD,
-        maxZ: z + halfD,
-    };
-}
-/** Scaled plan footprint used by legacy placement and door-clearance callers. */
-export function itemNodePlanAabb(node) {
-    if (node.type !== 'item')
-        return null;
-    if (!Array.isArray(node.asset.dimensions))
-        return null;
-    const [width, height, depth] = getScaledDimensions(node);
-    const rotationY = Array.isArray(node.rotation) ? (node.rotation[1] ?? 0) : 0;
-    if (![node.position[0], node.position[2], width, height, depth, rotationY].every(Number.isFinite)) {
-        return null;
-    }
-    return itemPlanAabb(node.position, [Math.abs(width), Math.abs(height), Math.abs(depth)], rotationY);
-}
-export function inspectItemPlanFootprint(node, options) {
-    if (options?.floorOnly &&
-        (node.asset.attachTo === 'wall' ||
-            node.asset.attachTo === 'wall-side' ||
-            node.asset.attachTo === 'ceiling')) {
-        return { ok: false, reason: 'unsupported_attachment' };
-    }
-    const position = node.position;
-    if (!Array.isArray(position)) {
-        return { ok: false, reason: 'non_finite_position' };
-    }
-    const x = position[0];
-    const y = position[1];
-    const z = position[2];
-    if (!(Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(z))) {
-        return { ok: false, reason: 'non_finite_position' };
-    }
-    const rotation = Array.isArray(node.rotation) ? node.rotation : [0, 0, 0];
-    const rotationX = rotation[0] ?? Number.NaN;
-    const rotationY = rotation[1] ?? Number.NaN;
-    const rotationZ = rotation[2] ?? Number.NaN;
-    if (!(Number.isFinite(rotationX) && Number.isFinite(rotationY) && Number.isFinite(rotationZ))) {
-        return { ok: false, reason: 'non_finite_rotation' };
-    }
-    if (Math.abs(rotationX) > 1e-6 || Math.abs(rotationZ) > 1e-6) {
-        return { ok: false, reason: 'non_planar_rotation' };
-    }
-    const dimensions = node.asset.dimensions;
-    if (!Array.isArray(dimensions) || dimensions.length !== 3) {
-        return { ok: false, reason: 'missing_dimensions' };
-    }
-    const width = dimensions[0] ?? Number.NaN;
-    const height = dimensions[1] ?? Number.NaN;
-    const depth = dimensions[2] ?? Number.NaN;
-    if (!(Number.isFinite(width) && Number.isFinite(height) && Number.isFinite(depth))) {
-        return { ok: false, reason: 'non_finite_dimensions' };
-    }
-    if (width <= 0 || depth <= 0) {
-        return { ok: false, reason: 'non_positive_plan_dimensions' };
-    }
-    const scale = Array.isArray(node.scale) ? node.scale : [1, 1, 1];
-    const scaleX = scale[0] ?? Number.NaN;
-    const scaleY = scale[1] ?? Number.NaN;
-    const scaleZ = scale[2] ?? Number.NaN;
-    if (!(Number.isFinite(scaleX) && Number.isFinite(scaleY) && Number.isFinite(scaleZ))) {
-        return { ok: false, reason: 'non_finite_scale' };
-    }
-    if (scaleX === 0 || scaleZ === 0) {
-        return { ok: false, reason: 'zero_plan_scale' };
-    }
-    const [scaledWidth, scaledHeight, scaledDepth] = getScaledDimensions(node);
-    const effectiveDimensions = [
-        Math.abs(scaledWidth),
-        Math.abs(scaledHeight),
-        Math.abs(scaledDepth),
-    ];
-    if (!effectiveDimensions.every(Number.isFinite)) {
-        return { ok: false, reason: 'non_finite_dimensions' };
-    }
-    if (effectiveDimensions[0] <= 0 || effectiveDimensions[2] <= 0) {
-        return { ok: false, reason: 'non_positive_plan_dimensions' };
-    }
-    return {
-        ok: true,
-        aabb: itemPlanAabb(node.position, effectiveDimensions, rotationY),
-        sourceDimensions: [width, height, depth],
-        effectiveDimensions,
-        rotationY,
-    };
-}
-/**
- * Build a rectangular keep-out around a wall door, extruded perpendicular to the wall
- * on both faces so either swing side is protected.
- */
-export function doorKeepoutFromWall(wall, door, options) {
-    const clearDepth = options?.clearDepth ?? DEFAULT_DOOR_CLEAR_DEPTH;
-    const sidePad = options?.sidePad ?? DEFAULT_DOOR_SIDE_PAD;
-    const length = wallLength(wall);
-    if (length <= 1e-6)
-        return null;
-    const width = typeof door.width === 'number' && door.width > 0 ? door.width : 0.9;
-    const localX = Array.isArray(door.position) ? (door.position[0] ?? length / 2) : length / 2;
-    const [sx, sz] = wall.start;
-    const [ex, ez] = wall.end;
-    const dx = (ex - sx) / length;
-    const dz = (ez - sz) / length;
-    const nx = -dz;
-    const nz = dx;
-    const half = width / 2 + sidePad;
-    const corners = [];
-    for (const along of [localX - half, localX + half]) {
-        const cx = sx + dx * along;
-        const cz = sz + dz * along;
-        for (const side of [-clearDepth, clearDepth]) {
-            corners.push([cx + nx * side, cz + nz * side]);
-        }
-    }
-    const xs = corners.map((c) => c[0]);
-    const zs = corners.map((c) => c[1]);
-    return {
-        doorId: door.id,
-        wallId: wall.id,
-        levelId: options?.levelId ?? null,
-        width,
-        localX,
-        aabb: {
-            minX: Math.min(...xs),
-            maxX: Math.max(...xs),
-            minZ: Math.min(...zs),
-            maxZ: Math.max(...zs),
-        },
-    };
-}
-export function collectDoorKeepouts(nodes, options) {
-    const byId = new Map();
-    for (const node of nodes)
-        byId.set(node.id, node);
-    const keepouts = [];
-    for (const node of byId.values()) {
-        if (node.type !== 'door')
-            continue;
-        const wallId = node.wallId ?? node.parentId;
-        if (!wallId)
-            continue;
-        const wall = byId.get(wallId);
-        if (wall?.type !== 'wall')
-            continue;
-        const levelId = resolveNodeLevelId(wall.id, byId) ?? resolveNodeLevelId(node.id, byId);
-        if (options?.levelId && levelId !== options.levelId)
-            continue;
-        const keepout = doorKeepoutFromWall(wall, node, {
-            clearDepth: options?.clearDepth,
-            sidePad: options?.sidePad,
-            levelId,
-        });
-        if (keepout)
-            keepouts.push(keepout);
-    }
-    return keepouts;
-}
-export function itemBlocksDoorKeepout(itemAabb, keepout) {
-    return aabbsOverlap(itemAabb, keepout.aabb, 0.02);
-}
-export function findBlockedDoors(args) {
-    const nodes = [...args.nodes];
-    const byId = new Map(nodes.map((n) => [n.id, n]));
-    const keepouts = collectDoorKeepouts(nodes, {
-        clearDepth: args.clearDepth,
-        sidePad: args.sidePad,
-        levelId: args.levelId,
-    });
-    if (keepouts.length === 0)
-        return [];
-    const issues = [];
-    for (const node of nodes) {
-        if (node.type !== 'item')
-            continue;
-        const itemLevel = resolveNodeLevelId(node.id, byId);
-        if (args.levelId && itemLevel !== args.levelId)
-            continue;
-        const aabb = itemNodePlanAabb(node);
-        if (!aabb)
-            continue;
-        for (const keepout of keepouts) {
-            // Same-level only (multi-story safety).
-            if (keepout.levelId && itemLevel && keepout.levelId !== itemLevel)
-                continue;
-            if (args.levelId && keepout.levelId && keepout.levelId !== args.levelId)
-                continue;
-            if (!itemBlocksDoorKeepout(aabb, keepout))
-                continue;
-            const itemName = node.name ?? node.asset?.name ?? node.id;
-            issues.push({
-                doorId: keepout.doorId,
-                wallId: keepout.wallId,
-                itemId: node.id,
-                levelId: itemLevel,
-                itemName: typeof itemName === 'string' ? itemName : undefined,
-                message: `Door ${keepout.doorId} on wall ${keepout.wallId} is blocked by item ${itemName} (${node.id})`,
-            });
-        }
-    }
-    return issues;
-}
-/**
- * Synthetic keep-outs for a room polygon edge that will host a door (before doors exist).
- * Used by furnish_room when doorWallIndex is known.
- */
-export function keepoutForPolygonEdge(polygon, edgeIndex, options) {
-    if (polygon.length < 3)
-        return null;
-    const i = ((edgeIndex % polygon.length) + polygon.length) % polygon.length;
-    const start = polygon[i];
-    const end = polygon[(i + 1) % polygon.length];
-    const wall = {
-        id: `edge-${i}`,
-        start,
-        end,
-    };
-    const length = wallLength(wall);
-    if (length <= 1e-6)
-        return null;
-    const width = options?.width ?? 0.9;
-    const t = options?.t ?? 0.5;
-    const localX = Math.min(Math.max(t * length, width / 2), length - width / 2);
-    const keepout = doorKeepoutFromWall(wall, {
-        id: `planned-door-${i}`,
-        position: [localX, 1.05, 0],
-        width,
-    }, { clearDepth: options?.clearDepth, sidePad: options?.sidePad });
-    return keepout?.aabb ?? null;
-}
-/**
- * Whether an existing keep-out already covers this room-edge planned zone
- * (so we do not double-count a real door on that edge).
- *
- * Requires the planned keep-out **center** to lie inside the existing keep-out,
- * and the existing box to cover a large fraction of the planned area.
- * Plain AABB overlap is not enough (nearby hallway doors must not suppress
- * this room's entrance keep-out).
- */
-export function keepoutCoversPlanned(existing, planned) {
-    const cx = (planned.minX + planned.maxX) / 2;
-    const cz = (planned.minZ + planned.maxZ) / 2;
-    const centerInside = cx >= existing.minX && cx <= existing.maxX && cz >= existing.minZ && cz <= existing.maxZ;
-    if (!centerInside)
-        return false;
-    // Intersection area / planned area must be substantial (same opening, not a glancing touch).
-    const ix0 = Math.max(existing.minX, planned.minX);
-    const ix1 = Math.min(existing.maxX, planned.maxX);
-    const iz0 = Math.max(existing.minZ, planned.minZ);
-    const iz1 = Math.min(existing.maxZ, planned.maxZ);
-    if (ix1 <= ix0 || iz1 <= iz0)
-        return false;
-    const inter = (ix1 - ix0) * (iz1 - iz0);
-    const plannedArea = Math.max(1e-9, (planned.maxX - planned.minX) * (planned.maxZ - planned.minZ));
-    return inter / plannedArea >= 0.5;
-}
-export function aabbFromPlan(a) {
-    return a;
-}

package/dist/tools/duplicate-level.d.ts

@@ -1,19 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
-import type { SceneOperations } from '../operations/index.js';
-export declare const duplicateLevelInput: {
-    levelId: z.ZodString;
-};
-export declare const duplicateLevelOutput: {
-    persistence: z.ZodOptional<z.ZodObject<{
-        status: z.ZodEnum<{
-            unbound: "unbound";
-            events_unsupported: "events_unsupported";
-        }>;
-        warning: z.ZodString;
-    }, z.core.$strip>>;
-    newLevelId: z.ZodString;
-    newNodeIds: z.ZodArray<z.ZodString>;
-};
-export declare function registerDuplicateLevel(server: McpServer, bridge: SceneOperations): void;
-//# sourceMappingURL=duplicate-level.d.ts.map

package/dist/tools/duplicate-level.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"duplicate-level.d.ts","sourceRoot":"","sources":["../../src/tools/duplicate-level.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAMpD,eAAO,MAAM,mBAAmB;;CAE/B,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;CAIhC,CAAA;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAwDvF"}

package/dist/tools/duplicate-level.js

@@ -1,60 +0,0 @@
-import { cloneLevelSubtree } from '@pascal-app/core/clone-scene-graph';
-import { z } from 'zod';
-import { ADDITIVE_TOOL_ANNOTATIONS } from './annotations.js';
-import { ErrorCode, throwMcpError } from './errors.js';
-import { liveSyncOutput, persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
-import { NodeIdSchema } from './schemas.js';
-export const duplicateLevelInput = {
-    levelId: NodeIdSchema,
-};
-export const duplicateLevelOutput = {
-    newLevelId: z.string(),
-    newNodeIds: z.array(z.string()),
-    ...liveSyncOutput,
-};
-export function registerDuplicateLevel(server, bridge) {
-    server.registerTool('duplicate_level', {
-        title: 'Duplicate level',
-        description: 'Clone a level and all its descendants into a new subtree attached to the same building.',
-        inputSchema: duplicateLevelInput,
-        outputSchema: duplicateLevelOutput,
-        annotations: ADDITIVE_TOOL_ANNOTATIONS,
-    }, async ({ levelId }) => {
-        const node = bridge.getNode(levelId);
-        if (!node) {
-            throwMcpError(ErrorCode.InvalidParams, `Level not found: ${levelId}`);
-        }
-        if (node.type !== 'level') {
-            throwMcpError(ErrorCode.InvalidParams, `Node ${levelId} is a ${node.type}, expected level`);
-        }
-        // cloneLevelSubtree(nodes, levelId) — returns { clonedNodes, newLevelId, idMap }.
-        const { clonedNodes, newLevelId } = cloneLevelSubtree(bridge.getNodes(), levelId);
-        const buildingId = node.parentId ?? undefined;
-        // Flatten cloned subtree into create patches. The level node itself
-        // attaches to the original building; descendants attach to their
-        // already-remapped parent (encoded in `parentId`).
-        const patches = clonedNodes.map((n) => {
-            const isRoot = n.id === newLevelId;
-            const parentIdForBridge = isRoot
-                ? buildingId
-                : (n.parentId ?? undefined);
-            const createOp = {
-                op: 'create',
-                node: n,
-                ...(parentIdForBridge !== undefined ? { parentId: parentIdForBridge } : {}),
-            };
-            return createOp;
-        });
-        const result = bridge.applyPatch(patches);
-        const persistence = await publishLiveSceneSnapshot(bridge, 'duplicate_level');
-        const payload = {
-            newLevelId: newLevelId,
-            newNodeIds: result.createdIds,
-            ...persistencePayload(persistence),
-        };
-        return {
-            content: [{ type: 'text', text: JSON.stringify(payload) }],
-            structuredContent: payload,
-        };
-    });
-}

package/dist/tools/find-nodes.d.ts

@@ -1,32 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
-import type { SceneOperations } from '../operations/index.js';
-export declare const findNodesInput: {
-    type: z.ZodOptional<z.ZodEnum<{
-        site: "site";
-        building: "building";
-        level: "level";
-        wall: "wall";
-        fence: "fence";
-        slab: "slab";
-        door: "door";
-        item: "item";
-        zone: "zone";
-        stair: "stair";
-        ceiling: "ceiling";
-        roof: "roof";
-        "roof-segment": "roof-segment";
-        "stair-segment": "stair-segment";
-        scan: "scan";
-        guide: "guide";
-        window: "window";
-    }>>;
-    parentId: z.ZodOptional<z.ZodString>;
-    levelId: z.ZodOptional<z.ZodString>;
-    zoneId: z.ZodOptional<z.ZodString>;
-};
-export declare const findNodesOutput: {
-    nodes: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-};
-export declare function registerFindNodes(server: McpServer, bridge: SceneOperations): void;
-//# sourceMappingURL=find-nodes.d.ts.map

package/dist/tools/find-nodes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"find-nodes.d.ts","sourceRoot":"","sources":["../../src/tools/find-nodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAwBpD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;CAK1B,CAAA;AAED,eAAO,MAAM,eAAe;;CAE3B,CAAA;AAkCD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAwDlF"}

package/dist/tools/find-nodes.js

@@ -1,107 +0,0 @@
-import { pointInPolygon } from '@pascal-app/core/spatial-grid';
-import { z } from 'zod';
-import { READ_ONLY_TOOL_ANNOTATIONS } from './annotations.js';
-import { NodeIdSchema } from './schemas.js';
-const ALL_NODE_TYPES = [
-    'site',
-    'building',
-    'level',
-    'wall',
-    'fence',
-    'zone',
-    'slab',
-    'ceiling',
-    'roof',
-    'roof-segment',
-    'stair',
-    'stair-segment',
-    'item',
-    'door',
-    'window',
-    'scan',
-    'guide',
-];
-export const findNodesInput = {
-    type: z.enum(ALL_NODE_TYPES).optional(),
-    parentId: NodeIdSchema.optional(),
-    levelId: NodeIdSchema.optional(),
-    zoneId: NodeIdSchema.optional(),
-};
-export const findNodesOutput = {
-    nodes: z.array(z.record(z.string(), z.unknown())),
-};
-/** Compute a representative 2D point (x, z) for zone-filtering. */
-function getPointForZoneFilter(node) {
-    if (node.type === 'wall' || node.type === 'fence') {
-        const [x1, z1] = node.start;
-        const [x2, z2] = node.end;
-        return [(x1 + x2) / 2, (z1 + z2) / 2];
-    }
-    if (node.type === 'item' ||
-        node.type === 'door' ||
-        node.type === 'window' ||
-        node.type === 'building' ||
-        node.type === 'stair' ||
-        node.type === 'roof') {
-        const [x, , z] = node.position;
-        return [x, z];
-    }
-    if (node.type === 'slab' || node.type === 'ceiling' || node.type === 'zone') {
-        const poly = node.polygon;
-        if (!poly || poly.length === 0)
-            return null;
-        let cx = 0;
-        let cz = 0;
-        for (const [x, z] of poly) {
-            cx += x;
-            cz += z;
-        }
-        return [cx / poly.length, cz / poly.length];
-    }
-    return null;
-}
-export function registerFindNodes(server, bridge) {
-    server.registerTool('find_nodes', {
-        title: 'Find nodes',
-        description: 'Find nodes matching any combination of type, parentId, levelId, or zoneId filters.',
-        inputSchema: findNodesInput,
-        outputSchema: findNodesOutput,
-        annotations: READ_ONLY_TOOL_ANNOTATIONS,
-    }, async (args) => {
-        const { type, parentId, levelId, zoneId } = args;
-        // Delegate type/parent/level filtering to the bridge.
-        const baseFilter = {};
-        if (type !== undefined)
-            baseFilter.type = type;
-        if (parentId !== undefined)
-            baseFilter.parentId = parentId;
-        if (levelId !== undefined)
-            baseFilter.levelId = levelId;
-        let results = bridge.findNodes(baseFilter);
-        // Zone-polygon filter: point-in-polygon on a representative 2D point.
-        if (zoneId) {
-            const zone = bridge.getNode(zoneId);
-            if (zone?.type !== 'zone') {
-                // Unknown zoneId → return empty list rather than throw; matches
-                // typical "filter" semantics.
-                results = [];
-            }
-            else {
-                const poly = zone.polygon;
-                results = results.filter((n) => {
-                    const pt = getPointForZoneFilter(n);
-                    if (!pt)
-                        return false;
-                    return pointInPolygon(pt[0], pt[1], poly);
-                });
-            }
-        }
-        const payload = {
-            nodes: results,
-        };
-        return {
-            content: [{ type: 'text', text: JSON.stringify(payload) }],
-            structuredContent: payload,
-        };
-    });
-}

package/dist/tools/geometry.d.ts

@@ -1,24 +0,0 @@
-import type { WallNode } from '@pascal-app/core/schema';
-export type Vec2 = [number, number];
-export type Vec3 = [number, number, number];
-export declare function distance2D(a: Vec2, b: Vec2): number;
-export declare function wallLength(wall: Pick<WallNode, 'start' | 'end'>): number;
-export declare function clamp(value: number, min: number, max: number): number;
-export declare function wallLocalXFromT(wall: Pick<WallNode, 'start' | 'end'>, t: number, width: number): number;
-export declare function projectWorldPointToWallLocalX(wall: Pick<WallNode, 'start' | 'end'>, position: Vec3): number;
-export declare function polygonArea(points: Vec2[]): number;
-export declare function polygonBounds(points: Vec2[]): {
-    minX: number;
-    maxX: number;
-    minZ: number;
-    maxZ: number;
-    width: number;
-    depth: number;
-    centerX: number;
-    centerZ: number;
-};
-export declare function pointInBoundsWithPadding(x: number, z: number, bounds: ReturnType<typeof polygonBounds>, padding: number): boolean;
-export declare function pointOnSegment(point: Vec2, a: Vec2, b: Vec2, tolerance?: number): boolean;
-export declare function pointInPolygon(point: Vec2, polygon: Vec2[], includeBoundary?: boolean): boolean;
-export declare function polygonContainsPolygon(outer: Vec2[], inner: Vec2[]): boolean;
-//# sourceMappingURL=geometry.d.ts.map

package/dist/tools/geometry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/tools/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAEvD,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AACnC,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAE3C,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CAInD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,GAAG,MAAM,CAExE;AAED,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAGrE;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,EACrC,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,MAAM,GACZ,MAAM,CAGR;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,EACrC,QAAQ,EAAE,IAAI,GACb,MAAM,CAWR;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,CASlD;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG;IAC7C,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB,CAiBA;AAED,wBAAgB,wBAAwB,CACtC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,EACxC,OAAO,EAAE,MAAM,GACd,OAAO,CAOT;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,SAAO,GAAG,OAAO,CAOvF;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,eAAe,UAAO,GAAG,OAAO,CAgB5F;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAE5E"}

package/dist/tools/geometry.js

@@ -1,94 +0,0 @@
-export function distance2D(a, b) {
-    const dx = b[0] - a[0];
-    const dz = b[1] - a[1];
-    return Math.sqrt(dx * dx + dz * dz);
-}
-export function wallLength(wall) {
-    return distance2D(wall.start, wall.end);
-}
-export function clamp(value, min, max) {
-    if (max < min)
-        return (min + max) / 2;
-    return Math.max(min, Math.min(max, value));
-}
-export function wallLocalXFromT(wall, t, width) {
-    const length = wallLength(wall);
-    return clamp(t * length, width / 2, length - width / 2);
-}
-export function projectWorldPointToWallLocalX(wall, position) {
-    const [sx, sz] = wall.start;
-    const [ex, ez] = wall.end;
-    const dx = ex - sx;
-    const dz = ez - sz;
-    const len = Math.sqrt(dx * dx + dz * dz);
-    if (len === 0)
-        return 0;
-    const px = position[0] - sx;
-    const pz = position[2] - sz;
-    const distance = px * (dx / len) + pz * (dz / len);
-    return clamp(distance, 0, len);
-}
-export function polygonArea(points) {
-    if (points.length < 3)
-        return 0;
-    let area = 0;
-    for (let i = 0; i < points.length; i++) {
-        const current = points[i];
-        const next = points[(i + 1) % points.length];
-        area += current[0] * next[1] - next[0] * current[1];
-    }
-    return Math.abs(area) / 2;
-}
-export function polygonBounds(points) {
-    const xs = points.map((p) => p[0]);
-    const zs = points.map((p) => p[1]);
-    const minX = Math.min(...xs);
-    const maxX = Math.max(...xs);
-    const minZ = Math.min(...zs);
-    const maxZ = Math.max(...zs);
-    return {
-        minX,
-        maxX,
-        minZ,
-        maxZ,
-        width: maxX - minX,
-        depth: maxZ - minZ,
-        centerX: (minX + maxX) / 2,
-        centerZ: (minZ + maxZ) / 2,
-    };
-}
-export function pointInBoundsWithPadding(x, z, bounds, padding) {
-    return (x >= bounds.minX + padding &&
-        x <= bounds.maxX - padding &&
-        z >= bounds.minZ + padding &&
-        z <= bounds.maxZ - padding);
-}
-export function pointOnSegment(point, a, b, tolerance = 1e-6) {
-    const cross = (point[1] - a[1]) * (b[0] - a[0]) - (point[0] - a[0]) * (b[1] - a[1]);
-    if (Math.abs(cross) > tolerance)
-        return false;
-    const dot = (point[0] - a[0]) * (b[0] - a[0]) + (point[1] - a[1]) * (b[1] - a[1]);
-    if (dot < -tolerance)
-        return false;
-    const lenSq = (b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2;
-    return dot <= lenSq + tolerance;
-}
-export function pointInPolygon(point, polygon, includeBoundary = true) {
-    if (polygon.length < 3)
-        return false;
-    let inside = false;
-    const [x, z] = point;
-    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
-        const a = polygon[i];
-        const b = polygon[j];
-        if (pointOnSegment(point, a, b))
-            return includeBoundary;
-        const intersects = a[1] > z !== b[1] > z && x < ((b[0] - a[0]) * (z - a[1])) / (b[1] - a[1]) + a[0];
-        if (intersects)
-            inside = !inside;
-    }
-    return inside;
-}
-export function polygonContainsPolygon(outer, inner) {
-    return inner.every((point) => pointInPolygon(point, outer, true));
-}