@sealab/mcp-server 1.0.3 → 1.0.4

package/dist/index.js

@@ -12,10 +12,11 @@ const configuration_info_1 = require("./tools/configuration-info");
 const saved_settings_1 = require("./tools/saved-settings");
 const canvas_1 = require("./tools/canvas");
 const permissions_1 = require("./tools/permissions");
+const projects_1 = require("./tools/projects");
 const ai_drawing_1 = require("./tools/ai-drawing");
 const ai_drawing_overlay_1 = require("./tools/ai-drawing-overlay");
 const schema_normalizer_1 = require("./schema-normalizer");
-const allTools = [...catalog_1.catalogTools, ...orders_1.orderTools, ...configuration_1.configurationTools, ...configuration_info_1.configurationInfoTools, ...saved_settings_1.savedSettingsTools, ...canvas_1.canvasTools, ...permissions_1.permissionTools, ...ai_drawing_1.aiDrawingTools, ...ai_drawing_overlay_1.aiDrawingOverlayTools];
+const allTools = [...catalog_1.catalogTools, ...orders_1.orderTools, ...configuration_1.configurationTools, ...configuration_info_1.configurationInfoTools, ...saved_settings_1.savedSettingsTools, ...canvas_1.canvasTools, ...permissions_1.permissionTools, ...projects_1.projectTools, ...ai_drawing_1.aiDrawingTools, ...ai_drawing_overlay_1.aiDrawingOverlayTools];
 const server = new index_js_1.Server({ name: 'sealab', version: '1.0.0' }, { capabilities: { tools: {} } });
 server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
     tools: allTools.map((t) => ({

package/dist/tools/ai-drawing.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.aiDrawingTools = exports.AiCabinetCoordinatesDeleteInputSchema = exports.AiCabinetCoordinatesPatchInputListSchema = exports.AiCabinetCoordinatesReplaceInputSchema = exports.AiCabinetCoordinatePatchInputSchema = exports.AiCabinetCoordinateInputSchema = exports.AiCanvasCabinetPlacementsDeleteInputSchema = exports.AiCanvasCabinetPlacementsPatchInputSchema = exports.AiCanvasCabinetPlacementsByCanvasInputSchema = exports.AiCanvasCabinetPlacementsUpsertInputSchema = exports.AiCanvasCabinetPlacementsReplaceInputSchema = exports.AiCanvasCabinetPlacementPatchSchema = exports.AiCanvasCabinetPlacementInputSchema = exports.AiCanvasImageDeleteInputSchema = exports.AiCanvasImageUploadInputSchema = exports.AiCanvasImageInputSchema = exports.AiCanvasMetadataInputSchema = exports.LinkAiCartToDrawingSessionInputSchema = exports.AiDrawingSessionReviewRenderInputSchema = exports.AiReduxCartImportInputSchema = exports.AiOrderReadyPayloadClearInputSchema = exports.AiOrderReadyPayloadSetInputSchema = exports.AiOrderReadyPayloadReadInputSchema = exports.DeleteAiCabinetInputSchema = exports.ConfigureAiCabinetInputSchema = exports.DuplicateAiCabinetInputSchema = exports.AiCartCreateInputSchema = exports.AiCartSnapshotInputSchema = exports.AiCartItemPatchSchema = exports.AiCartItemInputSchema = exports.AiCartItemIdParamSchema = exports.AiCartIdParamSchema = exports.AiDrawingSessionCreateInputSchema = exports.AiCanvasMetaSchema = exports.AiCanvasProjectionCalibrationSchema = void 0;
+exports.aiDrawingTools = exports.AiCabinetCoordinatesDeleteInputSchema = exports.AiCabinetCoordinatesPatchInputListSchema = exports.AiCabinetCoordinatesReplaceInputSchema = exports.AiCabinetCoordinatePatchInputSchema = exports.AiCabinetCoordinateInputSchema = exports.ProjectAiCanvasElevationRunInputSchema = exports.ProjectAiCanvasCabinetPlacementsInputSchema = exports.AiCanvasCabinetPlacementsDeleteInputSchema = exports.AiCanvasCabinetPlacementsPatchInputSchema = exports.AiCanvasCabinetPlacementsByCanvasInputSchema = exports.AiCanvasCabinetPlacementsUpsertInputSchema = exports.AiCanvasCabinetPlacementsReplaceInputSchema = exports.AiCanvasCabinetPlacementPatchSchema = exports.AiCanvasCabinetPlacementInputSchema = exports.AiCanvasImageDeleteInputSchema = exports.AiCanvasImageUploadInputSchema = exports.AiCanvasImageInputSchema = exports.AiCanvasMetadataInputSchema = exports.LinkAiCartToDrawingSessionInputSchema = exports.AiDrawingSessionReviewRenderInputSchema = exports.AiReduxCartImportInputSchema = exports.AiOrderReadyPayloadClearInputSchema = exports.AiOrderReadyPayloadSetInputSchema = exports.AiOrderReadyPayloadReadInputSchema = exports.DeleteAiCabinetInputSchema = exports.ConfigureAiCabinetInputSchema = exports.DuplicateAiCabinetInputSchema = exports.AiCartCreateInputSchema = exports.AiCartSnapshotInputSchema = exports.AiCartItemPatchSchema = exports.AiCartItemInputSchema = exports.AiCartItemIdParamSchema = exports.AiCartIdParamSchema = exports.AiDrawingSessionCreateInputSchema = exports.AiCanvasMetaSchema = exports.AiCanvasProjectionCalibrationSchema = void 0;
 exports.getAiDrawingState = getAiDrawingState;
 exports.renderAiDrawingSessionReviewTool = renderAiDrawingSessionReviewTool;
 exports.createAiDrawingSession = createAiDrawingSession;
@@ -51,6 +51,8 @@ exports.replaceAiCanvasCabinetPlacements = replaceAiCanvasCabinetPlacements;
 exports.upsertAiCanvasCabinetPlacements = upsertAiCanvasCabinetPlacements;
 exports.patchAiCanvasCabinetPlacements = patchAiCanvasCabinetPlacements;
 exports.deleteAiCanvasCabinetPlacements = deleteAiCanvasCabinetPlacements;
+exports.projectAiCanvasCabinetPlacements = projectAiCanvasCabinetPlacements;
+exports.projectAiCanvasElevationRun = projectAiCanvasElevationRun;
 exports.replaceAiCabinetCoordinates = replaceAiCabinetCoordinates;
 exports.patchAiCabinetCoordinates = patchAiCabinetCoordinates;
 exports.deleteAiCabinetCoordinates = deleteAiCabinetCoordinates;
@@ -74,6 +76,9 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const form_data_1 = __importDefault(require("form-data"));
 const ai_drawing_session_review_renderer_1 = require("./ai-drawing-session-review-renderer");
+const placement_projection_1 = require("./placement-projection");
+const elevation_run_segmentation_1 = require("./elevation-run-segmentation");
+const cart_cross_check_1 = require("./cart-cross-check");
 const LEGACY_DRAWING_TOOL_NAME = 'the legacy frontend drawing route';
 const STORED_CARTS_TERM = 'stored carts';
 const AI_CART_TOOL_BOUNDARY = 'AIDrawingTool is backend-owned and isolated. These tools do not mutate the Redux cart, ' +
@@ -723,6 +728,208 @@ exports.AiCanvasCabinetPlacementsDeleteInputSchema = AiDrawingSessionIdParamSche
     canvasType: CanvasTypeSchema,
     positionNames: zod_1.z.array(zod_1.z.string().min(1)).min(1).describe('Nonempty list of per-canvas placement positionName values to delete from exactly this canvas.'),
 }).strict().describe('Delete selected placements from one backend-owned AIDrawingTool canvas. ' + AI_CANVAS_PLACEMENT_GUIDANCE);
+// ---------------------------------------------------------------------------
+// Deterministic placement projection (project_ai_canvas_cabinet_placements)
+// ---------------------------------------------------------------------------
+const AI_PLACEMENT_PROJECTION_GUIDANCE = 'Compute exact per-canvas placement rectangles from one pixels-per-inch calibration plus each cabinet\'s real ' +
+    'inch dimensions, instead of eyeballing raw pixel boxes. This is the preferred way to create placements: a ' +
+    'vision model cannot reliably guess precise pixel rectangles, and per-box guesses drift, overlap, and double up ' +
+    'across rows of similar cabinets. Workflow: (1) read a visible dimension string and the finished-floor/Z0 line on ' +
+    'the actual source image to establish horizontalPixelsPerInch, verticalPixelsPerInch, floorZ0Px, and one horizontal ' +
+    'origin reference; (2) supply each cabinet face by its real along-wall start, width, body height, and ' +
+    'finished-floor-to-bottom height in inches (read width/height from the catalog/order-ready payload and the ' +
+    'drawing dimension strings, never from guessed pixels); (3) this tool projects every rectangle from the same scale ' +
+    'so the whole run stays aligned and gap-correct. imageSizePx, basisImageWidthPx, and basisImageHeightPx must all ' +
+    'equal the true pixel size of the source image the calibration was measured on, so the review renderer rescales ' +
+    'consistently. Elevation faces project along-wall position and height-above-floor; plan footprints project ' +
+    'room/global center X/Y with width/depth. After projecting, render_ai_drawing_session_review and verify against the ' +
+    'source pixels. ' +
+    AI_CANVAS_PLACEMENT_GUIDANCE;
+const ProjectionImageSizePxSchema = zod_1.z.object({
+    width: zod_1.z.number().finite().positive().describe('True source image width in pixels.'),
+    height: zod_1.z.number().finite().positive().describe('True source image height in pixels.'),
+}).strict();
+const ProjectionPixelPointSchema = zod_1.z.object({
+    x: zod_1.z.number().finite().describe('Image pixel X.'),
+    y: zod_1.z.number().finite().describe('Image pixel Y.'),
+}).strict();
+const ProjectorElevationCalibrationSchema = zod_1.z.object({
+    canvasType: ElevationCanvasTypeSchema.describe('Elevation canvas this calibration applies to.'),
+    imageSizePx: ProjectionImageSizePxSchema.describe('True pixel size of the elevation source image the calibration was measured on.'),
+    horizontalPixelsPerInch: zod_1.z.number().finite().positive().describe('Pixels per inch along the wall, derived from a visible horizontal dimension string.'),
+    verticalPixelsPerInch: zod_1.z.number().finite().positive().describe('Pixels per inch vertically, derived from a visible vertical dimension (e.g. ceiling height A.F.F.).'),
+    floorZ0Px: zod_1.z.number().finite().describe('Pixel Y of the finished-floor / Z0 reference line.'),
+    horizontalOriginPx: ProjectionPixelPointSchema.describe('A pixel point whose along-wall inch coordinate is known (e.g. the left wall corner).'),
+    horizontalOriginCoordinateInches: zod_1.z.number().finite().default(0).describe('The along-wall inch coordinate that horizontalOriginPx maps to. Usually 0 at the chosen origin.'),
+    horizontalAxisPositiveDirection: AxisHorizontalDirectionSchema.describe('Screen direction in which the along-wall inch coordinate increases.'),
+    verticalAxisPositiveDirection: AxisVerticalDirectionSchema.default('up').describe('Screen direction in which height-above-floor increases. Normally "up".'),
+}).strict();
+const ProjectorPlanCalibrationSchema = zod_1.z.object({
+    canvasType: zod_1.z.literal('plan'),
+    imageSizePx: ProjectionImageSizePxSchema.describe('True pixel size of the plan source image the calibration was measured on.'),
+    pixelsPerInch: zod_1.z.number().finite().positive().describe('Pixels per room inch on the plan.'),
+    roomOriginPx: ProjectionPixelPointSchema.describe('Pixel point that maps to room/global origin (0, 0).'),
+    xPositiveDirection: AxisHorizontalDirectionSchema.describe('Screen direction in which room X increases.'),
+    yPositiveDirection: AxisVerticalDirectionSchema.describe('Screen direction in which room Y increases.'),
+}).strict();
+const ProjectorPlacementSpecSchema = zod_1.z.object({
+    aiCartItemId: zod_1.z.string().uuid().optional().describe('Optional backend AI cart item UUID. Required unless positionName exactly matches an active AI cart item.'),
+    positionName: zod_1.z.string().min(1).describe('Physical AI cart item positionName and per-canvas placement identity.'),
+    // Elevation fields
+    horizontalStartInches: zod_1.z.number().finite().optional().describe('Elevation only: left edge of the face along the wall, in the wall\'s horizontal inch coordinate.'),
+    heightInches: zod_1.z.number().finite().positive().optional().describe('Elevation only: cabinet face height in inches (base cabinet body height excludes toekick and countertop).'),
+    bottomFromFloorInches: zod_1.z.number().finite().nonnegative().default(0).describe('Elevation only: finished-floor-to-bottom of this face in inches. 0 for a base cabinet on the floor.'),
+    // Plan fields (center mode)
+    centerXInches: zod_1.z.number().finite().optional().describe('Plan center mode: cabinet center X in room/global inches.'),
+    centerYInches: zod_1.z.number().finite().optional().describe('Plan center mode: cabinet center Y in room/global inches.'),
+    depthInches: zod_1.z.number().finite().positive().optional().describe('Plan only: cabinet front-to-back depth in inches.'),
+    rotation: CoordinateRotationSchema.optional().describe('Plan center mode: wall rotation 0/90/180/270; swaps width/depth axes.'),
+    // Plan fields (wall-anchored mode — preferred: pins the back edge to the wall so the box cannot bleed into the wall)
+    wallBackEdgeInches: zod_1.z.number().finite().optional().describe('Plan wall-anchored mode: room-inch coordinate of the cabinet BACK edge on the depth axis — i.e. the wall inner face. The footprint grows into the room from here.'),
+    depthAxis: zod_1.z.enum(['x', 'y']).optional().describe('Plan wall-anchored mode: room axis perpendicular to the wall (the depth direction).'),
+    depthDirection: zod_1.z.enum(['positive', 'negative']).optional().describe('Plan wall-anchored mode: direction in room coordinates that depth grows from the wall into the room.'),
+    alongWallStartInches: zod_1.z.number().finite().optional().describe('Plan wall-anchored mode: start of the run along the wall, in room inches on the non-depth axis.'),
+    // Common
+    widthInches: zod_1.z.number().finite().positive().describe('Cabinet width in inches (along the face / along the wall).'),
+}).strict();
+exports.ProjectAiCanvasCabinetPlacementsInputSchema = AiDrawingSessionIdParamSchema.extend({
+    canvasType: CanvasTypeSchema,
+    elevationCalibration: ProjectorElevationCalibrationSchema.optional().describe('Required when canvasType is an elevation (north/south/east/west).'),
+    planCalibration: ProjectorPlanCalibrationSchema.optional().describe('Required when canvasType is plan.'),
+    placements: zod_1.z.array(ProjectorPlacementSpecSchema).min(1).describe('Cabinet specs in real inches. Elevation specs need horizontalStartInches + widthInches + heightInches ' +
+        '(+ optional bottomFromFloorInches). Plan specs need centerXInches + centerYInches + widthInches + depthInches ' +
+        '(+ optional rotation).'),
+    writeMode: zod_1.z.enum(['replace', 'upsert', 'return_only']).default('upsert').describe('replace: overwrite all placements on this canvas. upsert: create/update by positionName without deleting others. ' +
+        'return_only: compute and return rectangles without writing to the backend (useful for a dry run before committing).'),
+    crossCheckCartItems: zod_1.z.boolean().default(true).describe('When true (default), verify each placement against the active AI cart manifest before writing: every placement ' +
+        'must match a real cart item and its width/height must match that cabinet (within tolerance). Blocks the write on ' +
+        'mismatch so a box cannot be stretched to cover multiple cabinets. Set false only for a calibration dry run.'),
+    widthToleranceInches: zod_1.z.number().finite().positive().optional().describe('Allowed width difference vs the cart item (default 1.0").'),
+    heightToleranceInches: zod_1.z.number().finite().positive().optional().describe('Allowed height/depth difference vs the cart item (default 1.5").'),
+    source: PlacementSourceSchema.optional(),
+}).strict().superRefine((input, ctx) => {
+    const isPlan = input.canvasType === 'plan';
+    if (isPlan && !input.planCalibration) {
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['planCalibration'], message: 'planCalibration is required when canvasType is plan.' });
+    }
+    if (isPlan && input.elevationCalibration) {
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['elevationCalibration'], message: 'Do not provide elevationCalibration for a plan canvas.' });
+    }
+    if (!isPlan && !input.elevationCalibration) {
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['elevationCalibration'], message: 'elevationCalibration is required when canvasType is an elevation.' });
+    }
+    if (!isPlan && input.planCalibration) {
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['planCalibration'], message: 'Do not provide planCalibration for an elevation canvas.' });
+    }
+    if (!isPlan && input.elevationCalibration && input.elevationCalibration.canvasType !== input.canvasType) {
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['elevationCalibration', 'canvasType'], message: 'elevationCalibration.canvasType must match canvasType.' });
+    }
+    input.placements.forEach((placement, index) => {
+        if (isPlan) {
+            if (placement.depthInches === undefined) {
+                ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['placements', index, 'depthInches'], message: 'depthInches is required for plan placements.' });
+            }
+            const hasWallAnchor = placement.wallBackEdgeInches !== undefined ||
+                placement.depthAxis !== undefined ||
+                placement.depthDirection !== undefined ||
+                placement.alongWallStartInches !== undefined;
+            const hasCenter = placement.centerXInches !== undefined || placement.centerYInches !== undefined;
+            if (hasWallAnchor) {
+                // Wall-anchored mode (preferred): all four anchor fields required, and no center fields.
+                for (const field of ['wallBackEdgeInches', 'depthAxis', 'depthDirection', 'alongWallStartInches']) {
+                    if (placement[field] === undefined) {
+                        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['placements', index, field], message: `${field} is required for wall-anchored plan placements.` });
+                    }
+                }
+                if (hasCenter) {
+                    ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['placements', index, 'centerXInches'], message: 'Use either wall-anchored fields or centerXInches/centerYInches, not both.' });
+                }
+            }
+            else {
+                // Center mode (fallback).
+                if (placement.centerXInches === undefined) {
+                    ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['placements', index, 'centerXInches'], message: 'Provide wall-anchored fields (preferred) or centerXInches for plan placements.' });
+                }
+                if (placement.centerYInches === undefined) {
+                    ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['placements', index, 'centerYInches'], message: 'Provide wall-anchored fields (preferred) or centerYInches for plan placements.' });
+                }
+            }
+        }
+        else {
+            if (placement.horizontalStartInches === undefined) {
+                ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['placements', index, 'horizontalStartInches'], message: 'horizontalStartInches is required for elevation placements.' });
+            }
+            if (placement.heightInches === undefined) {
+                ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['placements', index, 'heightInches'], message: 'heightInches is required for elevation placements.' });
+            }
+            if (placement.rotation !== undefined && placement.rotation !== 0) {
+                ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['placements', index, 'rotation'], message: AI_CANVAS_PLACEMENT_ROTATION_GUIDANCE });
+            }
+        }
+    });
+    validateUniquePositionNamesForCanvas(input.placements, ctx);
+}).describe('Project exact AIDrawingTool per-canvas cabinet placement rectangles from a pixels-per-inch calibration and real ' +
+    'cabinet inch dimensions, then optionally write them. ' + AI_PLACEMENT_PROJECTION_GUIDANCE);
+const AI_ELEVATION_RUN_SEGMENTATION_GUIDANCE = 'Decompose each dimensioned elevation run into its individual physical cabinets BEFORE placing boxes, so each ' +
+    'cabinet gets its own rectangle instead of one box spanning a whole run. This fixes under-segmentation, where a ' +
+    'multi-cabinet run (for example a 3\'-0" "EQ A | EQ A" upper that is actually two double-door cabinets) is wrongly ' +
+    'treated as a single cabinet. Workflow per run: (1) read the primary dimension string for the run total and the ' +
+    'secondary chain (EQ / EQ A / EQ B subdivisions) plus the "2" TYP." reveals and the visible vertical seams between ' +
+    'cabinets and doors; (2) decide how many physical cabinets the run contains — a vertical seam with its own stiles ' +
+    'and a separate cart item is a separate cabinet, whereas two doors sharing one box with no center stile gap are one ' +
+    'double-door cabinet; (3) enumerate the modules left to right, each with its real width and an explicit frontType ' +
+    '(single_door, double_door, drawer_stack, etc.) and its own positionName/aiCartItemId; (4) this tool tiles them ' +
+    'contiguously, projects one rectangle per module from the shared calibration, and returns segmentationWarnings when ' +
+    'a module looks too wide for one cabinet, a door type is implausible for its width, the module count is fewer than ' +
+    'the equal subdivisions you read, or the widths do not match the run dimension. Resolve every segmentationWarning ' +
+    'by re-reading the source drawing and creating the correct number of cabinets (each with its own AI cart item) ' +
+    'before reporting completion. Each module must correspond to a real AI cart item; do not invent modules to satisfy ' +
+    'the dimension total. ' +
+    AI_PLACEMENT_PROJECTION_GUIDANCE;
+const ProjectorElevationRunModuleSchema = zod_1.z.object({
+    positionName: zod_1.z.string().min(1).describe('Physical AI cart item positionName / placement identity for this single cabinet.'),
+    aiCartItemId: zod_1.z.string().uuid().optional().describe('Backend AI cart item UUID for this cabinet. Required unless positionName matches an active AI cart item.'),
+    widthInches: zod_1.z.number().finite().positive().describe('Real cabinet width in inches for this one module.'),
+    heightInches: zod_1.z.number().finite().positive().describe('Real cabinet face height in inches (base body height excludes toekick/countertop).'),
+    bottomFromFloorInches: zod_1.z.number().finite().nonnegative().default(0).describe('Finished-floor-to-bottom of this face in inches.'),
+    frontType: zod_1.z.enum([
+        'single_door',
+        'double_door',
+        'pair_of_doors',
+        'drawer_stack',
+        'door_over_drawer',
+        'open_shelf',
+        'appliance_panel',
+        'filler',
+    ]).describe('Front type for this module. Declaring it forces the single-vs-double-door determination per cabinet.'),
+}).strict();
+const ProjectorElevationRunSchema = zod_1.z.object({
+    runStartInches: zod_1.z.number().finite().describe('Along-wall inch coordinate of this run\'s left edge, in the calibration horizontal coordinate.'),
+    modules: zod_1.z.array(ProjectorElevationRunModuleSchema).min(1).describe('Ordered left-to-right cabinets that make up this run.'),
+    expectedRunTotalInches: zod_1.z.number().finite().positive().optional().describe('Run total from the primary dimension string (e.g. 3\'-0" => 36). Used to warn when module widths do not add up.'),
+    declaredSubdivisionCount: zod_1.z.number().int().positive().optional().describe('Number of equal subdivisions you read in the secondary chain (e.g. "EQ A | EQ A" => 2). Warns if you provide fewer modules.'),
+    revealBetweenModulesInches: zod_1.z.number().finite().nonnegative().optional().describe('Reveal/gap between adjacent cabinets in inches (e.g. "2" TYP.").'),
+    maxSingleCabinetWidthInches: zod_1.z.number().finite().positive().optional().describe('Width above which a module is flagged as suspected multiple cabinets. Default 48.'),
+}).strict();
+exports.ProjectAiCanvasElevationRunInputSchema = AiDrawingSessionIdParamSchema.extend({
+    canvasType: ElevationCanvasTypeSchema.describe('Elevation canvas (north/south/east/west). Run segmentation is elevation-only.'),
+    elevationCalibration: ProjectorElevationCalibrationSchema,
+    runs: zod_1.z.array(ProjectorElevationRunSchema).min(1).describe('One or more dimensioned runs to decompose and place.'),
+    writeMode: zod_1.z.enum(['replace', 'upsert', 'return_only']).default('upsert').describe('replace: overwrite all placements on this canvas. upsert: create/update by positionName. return_only: dry run.'),
+    crossCheckCartItems: zod_1.z.boolean().default(true).describe('When true (default), verify each module against the active AI cart manifest before writing: every module must ' +
+        'match a real cart item of matching width/height. Blocks the write on mismatch, so a run can only hold as many ' +
+        'cabinets as there are real items of the right size. Set false only for a calibration dry run.'),
+    widthToleranceInches: zod_1.z.number().finite().positive().optional().describe('Allowed width difference vs the cart item (default 1.0").'),
+    heightToleranceInches: zod_1.z.number().finite().positive().optional().describe('Allowed height difference vs the cart item (default 1.5").'),
+    source: PlacementSourceSchema.optional(),
+}).strict().superRefine((input, ctx) => {
+    if (input.elevationCalibration.canvasType !== input.canvasType) {
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['elevationCalibration', 'canvasType'], message: 'elevationCalibration.canvasType must match canvasType.' });
+    }
+    const allPositionNames = input.runs.flatMap((run) => run.modules.map((m) => m.positionName));
+    validateUniquePositionNamesForCanvas(allPositionNames.map((positionName) => ({ positionName })), ctx);
+}).describe('Decompose dimensioned elevation runs into individual cabinets and project one placement rectangle per cabinet. ' +
+    AI_ELEVATION_RUN_SEGMENTATION_GUIDANCE);
 const AiCoordinateDerivationEvidenceSchema = zod_1.z.object({
     basis: zod_1.z.enum(['validated_plan_placement', 'user_confirmed']).describe('How this canonical x/y/z coordinate was derived. MCP must not write canonical coordinates from guessed elevation rectangles.'),
     sourceCanvasType: zod_1.z.literal('plan').describe('Canonical x/y coordinates must be derived from validated plan placement geometry, not elevation-local pixels.'),
@@ -773,8 +980,31 @@ function validatePlacementRotationsForCanvas(canvasType, placements, ctx) {
         }
     });
 }
+function validateUniquePositionNamesForCanvas(placements, ctx) {
+    const seenIndexByPositionName = new Map();
+    placements.forEach((placement, index) => {
+        const positionName = placement.positionName;
+        if (positionName === undefined) {
+            return;
+        }
+        const firstIndex = seenIndexByPositionName.get(positionName);
+        if (firstIndex !== undefined) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['placements', index, 'positionName'],
+                message: `Duplicate positionName "${positionName}" in one canvas write. Each physical cabinet must have exactly ` +
+                    'one placement per canvas; duplicates render as stacked/doubled boxes. Use one placement per positionName ' +
+                    'on this canvas and reuse the same positionName on other canvases instead.',
+            });
+        }
+        else {
+            seenIndexByPositionName.set(positionName, index);
+        }
+    });
+}
 function validatePlacementOperationForCanvas(canvasType, placements, ctx) {
     validatePlacementRotationsForCanvas(canvasType, placements, ctx);
+    validateUniquePositionNamesForCanvas(placements, ctx);
 }
 exports.AiCabinetCoordinateInputSchema = zod_1.z.object({
     positionName: zod_1.z.string().min(1).describe('Required AI drawing coordinate identity. It is unique within an AI drawing session.'),
@@ -1200,6 +1430,319 @@ async function deleteAiCanvasCabinetPlacements(input) {
         return 'Unexpected error deleting AI canvas cabinet placements.';
     }
 }
+async function fetchActiveAiCartItems(sessionId) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.get(`/sessions/${sessionId}/state`);
+        const items = data?.activeCart?.items;
+        if (!Array.isArray(items)) {
+            return {
+                error: 'Could not read an active AI cart for this session, so placements cannot be cross-checked against the ' +
+                    'manifest. Create the AI cart, link it to the session, and sync items first (create_ai_cart / ' +
+                    'link_ai_cart_to_drawing_session / sync_ai_cart_snapshot), or rerun with crossCheckCartItems false for a dry run.',
+            };
+        }
+        return { items: items };
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return { error: e.message };
+        }
+        return { error: 'Unexpected error reading AI drawing session state for cart cross-check.' };
+    }
+}
+function buildCrossCheckBlockedResult(sessionId, canvasType, result, extra) {
+    return JSON.stringify({
+        sessionId,
+        canvasType,
+        wrote: false,
+        crossCheckBlocked: true,
+        matchedCartItemCount: result.matchedCount,
+        cartCrossCheckBlocking: result.blocking,
+        cartCrossCheckWarnings: result.warnings,
+        ...extra,
+        note: 'Write blocked: placements did not reconcile with the active AI cart manifest. Each placement must match a ' +
+            'real cart item and its real-world dimensions. Fix the cabinet count/widths (or the cart items) and rerun. ' +
+            'This guarantees a run cannot hold more cabinets than there are real items of the right size.',
+    }, null, 2);
+}
+async function projectAiCanvasCabinetPlacements(input) {
+    const isPlan = input.canvasType === 'plan';
+    const imageSizePx = isPlan
+        ? input.planCalibration.imageSizePx
+        : input.elevationCalibration.imageSizePx;
+    const elevationCalibration = isPlan
+        ? undefined
+        : {
+            canvasType: input.elevationCalibration.canvasType,
+            imageSizePx: input.elevationCalibration.imageSizePx,
+            horizontalPixelsPerInch: input.elevationCalibration.horizontalPixelsPerInch,
+            verticalPixelsPerInch: input.elevationCalibration.verticalPixelsPerInch,
+            floorZ0Px: input.elevationCalibration.floorZ0Px,
+            horizontalOriginPx: input.elevationCalibration.horizontalOriginPx,
+            horizontalOriginCoordinateInches: input.elevationCalibration.horizontalOriginCoordinateInches,
+            horizontalAxisPositiveDirection: input.elevationCalibration.horizontalAxisPositiveDirection,
+            verticalAxisPositiveDirection: input.elevationCalibration.verticalAxisPositiveDirection,
+        };
+    const planCalibration = isPlan
+        ? {
+            canvasType: 'plan',
+            imageSizePx: input.planCalibration.imageSizePx,
+            pixelsPerInch: input.planCalibration.pixelsPerInch,
+            roomOriginPx: input.planCalibration.roomOriginPx,
+            xPositiveDirection: input.planCalibration.xPositiveDirection,
+            yPositiveDirection: input.planCalibration.yPositiveDirection,
+        }
+        : undefined;
+    const outOfBounds = [];
+    const projectedPlacements = input.placements.map((spec) => {
+        const isWallAnchored = isPlan && spec.wallBackEdgeInches !== undefined;
+        const projected = isWallAnchored
+            ? (0, placement_projection_1.projectPlanWallAnchoredPlacement)({
+                wallBackEdgeInches: spec.wallBackEdgeInches,
+                depthAxis: spec.depthAxis,
+                depthDirection: spec.depthDirection,
+                alongWallStartInches: spec.alongWallStartInches,
+                widthInches: spec.widthInches,
+                depthInches: spec.depthInches,
+            }, planCalibration)
+            : isPlan
+                ? (0, placement_projection_1.projectPlanPlacement)({
+                    centerXInches: spec.centerXInches,
+                    centerYInches: spec.centerYInches,
+                    widthInches: spec.widthInches,
+                    depthInches: spec.depthInches,
+                    rotation: spec.rotation,
+                }, planCalibration)
+                : (0, placement_projection_1.projectElevationPlacement)({
+                    horizontalStartInches: spec.horizontalStartInches,
+                    widthInches: spec.widthInches,
+                    heightInches: spec.heightInches,
+                    bottomFromFloorInches: spec.bottomFromFloorInches,
+                }, elevationCalibration);
+        if ((0, placement_projection_1.isProjectedPlacementOutsideImage)(projected, imageSizePx)) {
+            outOfBounds.push({
+                positionName: spec.positionName,
+                reason: `Projected rectangle (centerX ${projected.centerX}, centerY ${projected.centerY}, width ${projected.width}, ` +
+                    `height ${projected.height}) extends outside the ${imageSizePx.width}x${imageSizePx.height} calibration image. ` +
+                    'Re-check the calibration (pixels-per-inch, origin, floor line) or the cabinet inch dimensions against the source drawing.',
+            });
+        }
+        return {
+            aiCartItemId: spec.aiCartItemId,
+            positionName: spec.positionName,
+            centerX: projected.centerX,
+            centerY: projected.centerY,
+            width: projected.width,
+            height: projected.height,
+            rotation: projected.rotation,
+            placementSpace: 'IMAGE_PIXELS',
+            basisImageWidthPx: imageSizePx.width,
+            basisImageHeightPx: imageSizePx.height,
+            source: input.source,
+        };
+    });
+    let crossCheckExtra;
+    if (input.crossCheckCartItems) {
+        const cart = await fetchActiveAiCartItems(input.sessionId);
+        if ('error' in cart) {
+            return cart.error;
+        }
+        const checkSpecs = input.placements.map((spec) => ({
+            positionName: spec.positionName,
+            aiCartItemId: spec.aiCartItemId,
+            widthInches: spec.widthInches,
+            heightInches: isPlan ? undefined : spec.heightInches,
+            depthInches: isPlan ? spec.depthInches : undefined,
+        }));
+        const result = (0, cart_cross_check_1.crossCheckPlacementsAgainstCart)(checkSpecs, cart.items, {
+            widthToleranceInches: input.widthToleranceInches,
+            heightToleranceInches: input.heightToleranceInches,
+            depthToleranceInches: input.heightToleranceInches,
+            reportCoverage: input.writeMode === 'replace',
+        });
+        if (result.blocking.length > 0) {
+            return buildCrossCheckBlockedResult(input.sessionId, input.canvasType, result);
+        }
+        crossCheckExtra = {
+            matchedCartItemCount: result.matchedCount,
+            cartCrossCheckWarnings: result.warnings,
+        };
+    }
+    return commitProjectedPlacements({
+        sessionId: input.sessionId,
+        canvasType: input.canvasType,
+        writeMode: input.writeMode,
+        imageSizePx,
+        projectedPlacements,
+        outOfBounds,
+        extra: crossCheckExtra,
+    });
+}
+async function commitProjectedPlacements(params) {
+    const { sessionId, canvasType, writeMode, imageSizePx, projectedPlacements, outOfBounds, extra } = params;
+    if (writeMode === 'return_only') {
+        return JSON.stringify({
+            sessionId,
+            canvasType,
+            writeMode,
+            wrote: false,
+            basisImageWidthPx: imageSizePx.width,
+            basisImageHeightPx: imageSizePx.height,
+            projectedPlacements: projectedPlacements.map(toBackendPlacementPayload),
+            outOfBoundsWarnings: outOfBounds,
+            ...extra,
+            note: 'return_only dry run: nothing was written. Inspect projectedPlacements, outOfBoundsWarnings, and any ' +
+                'segmentationWarnings, then rerun with writeMode upsert or replace to persist. After writing, call ' +
+                'render_ai_drawing_session_review and verify against the source image.',
+        }, null, 2);
+    }
+    try {
+        const path = `/sessions/${sessionId}/placements/${canvasType}`;
+        const body = { placements: projectedPlacements.map(toBackendPlacementPayload) };
+        const { data } = writeMode === 'replace' ? await api_client_1.aiDrawingClient.put(path, body) : await api_client_1.aiDrawingClient.post(path, body);
+        return JSON.stringify({
+            sessionId,
+            canvasType,
+            writeMode,
+            wrote: true,
+            basisImageWidthPx: imageSizePx.width,
+            basisImageHeightPx: imageSizePx.height,
+            projectedPlacementCount: projectedPlacements.length,
+            outOfBoundsWarnings: outOfBounds,
+            ...extra,
+            backendResponse: data,
+            note: 'Placements were projected from calibration and written. Resolve any segmentationWarnings, then call ' +
+                'render_ai_drawing_session_review and verify each rectangle against the visible source linework before reporting completion.',
+        }, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error projecting and writing AI canvas cabinet placements.';
+    }
+}
+async function projectAiCanvasElevationRun(input) {
+    const cal = input.elevationCalibration;
+    const imageSizePx = cal.imageSizePx;
+    const elevationCalibration = {
+        canvasType: cal.canvasType,
+        imageSizePx: cal.imageSizePx,
+        horizontalPixelsPerInch: cal.horizontalPixelsPerInch,
+        verticalPixelsPerInch: cal.verticalPixelsPerInch,
+        floorZ0Px: cal.floorZ0Px,
+        horizontalOriginPx: cal.horizontalOriginPx,
+        horizontalOriginCoordinateInches: cal.horizontalOriginCoordinateInches,
+        horizontalAxisPositiveDirection: cal.horizontalAxisPositiveDirection,
+        verticalAxisPositiveDirection: cal.verticalAxisPositiveDirection,
+    };
+    // Decompose each run into tiled modules — one placement per physical cabinet.
+    const segmentationWarnings = [];
+    const segmentedModules = [];
+    input.runs.forEach((run, runIndex) => {
+        const result = (0, elevation_run_segmentation_1.segmentElevationRun)({
+            runStartInches: run.runStartInches,
+            modules: run.modules,
+            expectedRunTotalInches: run.expectedRunTotalInches,
+            declaredSubdivisionCount: run.declaredSubdivisionCount,
+            revealBetweenModulesInches: run.revealBetweenModulesInches,
+            maxSingleCabinetWidthInches: run.maxSingleCabinetWidthInches,
+        });
+        for (const warning of result.warnings) {
+            segmentationWarnings.push(`run[${runIndex}]: ${warning}`);
+        }
+        for (const m of result.modules) {
+            segmentedModules.push({
+                positionName: m.positionName,
+                aiCartItemId: m.aiCartItemId,
+                horizontalStartInches: m.horizontalStartInches,
+                widthInches: m.widthInches,
+                heightInches: m.heightInches,
+                bottomFromFloorInches: m.bottomFromFloorInches,
+                frontType: m.frontType,
+                runIndex,
+            });
+        }
+    });
+    const outOfBounds = [];
+    const projectedPlacements = segmentedModules.map((m) => {
+        const projected = (0, placement_projection_1.projectElevationPlacement)({
+            horizontalStartInches: m.horizontalStartInches,
+            widthInches: m.widthInches,
+            heightInches: m.heightInches,
+            bottomFromFloorInches: m.bottomFromFloorInches,
+        }, elevationCalibration);
+        if ((0, placement_projection_1.isProjectedPlacementOutsideImage)(projected, imageSizePx)) {
+            outOfBounds.push({
+                positionName: m.positionName,
+                reason: `Projected rectangle for ${m.positionName} extends outside the ${imageSizePx.width}x${imageSizePx.height} ` +
+                    'calibration image. Re-check the calibration or this module\'s width/height/start against the source drawing.',
+            });
+        }
+        return {
+            aiCartItemId: m.aiCartItemId,
+            positionName: m.positionName,
+            centerX: projected.centerX,
+            centerY: projected.centerY,
+            width: projected.width,
+            height: projected.height,
+            rotation: 0,
+            placementSpace: 'IMAGE_PIXELS',
+            basisImageWidthPx: imageSizePx.width,
+            basisImageHeightPx: imageSizePx.height,
+            source: input.source,
+        };
+    });
+    const segmentationExtra = {
+        moduleCount: segmentedModules.length,
+        runCount: input.runs.length,
+        segmentationWarnings,
+        moduleSummary: segmentedModules.map((m) => ({
+            positionName: m.positionName,
+            runIndex: m.runIndex,
+            frontType: m.frontType,
+            widthInches: m.widthInches,
+            horizontalStartInches: m.horizontalStartInches,
+        })),
+    };
+    if (input.crossCheckCartItems) {
+        const cart = await fetchActiveAiCartItems(input.sessionId);
+        if ('error' in cart) {
+            return cart.error;
+        }
+        const checkSpecs = segmentedModules.map((m) => ({
+            positionName: m.positionName,
+            aiCartItemId: m.aiCartItemId,
+            widthInches: m.widthInches,
+            heightInches: m.heightInches,
+        }));
+        const result = (0, cart_cross_check_1.crossCheckPlacementsAgainstCart)(checkSpecs, cart.items, {
+            widthToleranceInches: input.widthToleranceInches,
+            heightToleranceInches: input.heightToleranceInches,
+            reportCoverage: input.writeMode === 'replace',
+        });
+        if (result.blocking.length > 0) {
+            return buildCrossCheckBlockedResult(input.sessionId, input.canvasType, result, segmentationExtra);
+        }
+        segmentationExtra.matchedCartItemCount = result.matchedCount;
+        segmentationExtra.cartCrossCheckWarnings = result.warnings;
+    }
+    return commitProjectedPlacements({
+        sessionId: input.sessionId,
+        canvasType: input.canvasType,
+        writeMode: input.writeMode,
+        imageSizePx,
+        projectedPlacements,
+        outOfBounds,
+        extra: segmentationExtra,
+    });
+}
 async function replaceAiCabinetCoordinates(input) {
     try {
         const { data } = await api_client_1.aiDrawingClient.put(`/sessions/${input.sessionId}/coordinates`, {
@@ -1942,6 +2485,25 @@ exports.aiDrawingTools = [
         inputSchema: exports.AiCanvasCabinetPlacementsDeleteInputSchema,
         handler: deleteAiCanvasCabinetPlacements,
     },
+    {
+        name: 'project_ai_canvas_cabinet_placements',
+        description: 'Compute and write exact backend-owned AIDrawingTool per-canvas cabinet placement rectangles from a ' +
+            'pixels-per-inch calibration plus real cabinet inch dimensions. Prefer this over hand-writing centerX/centerY/' +
+            'width/height placement boxes: it removes pixel-guessing error and keeps a whole run of cabinets aligned and ' +
+            'gap-correct from one shared scale. ' +
+            AI_PLACEMENT_PROJECTION_GUIDANCE,
+        inputSchema: exports.ProjectAiCanvasCabinetPlacementsInputSchema,
+        handler: projectAiCanvasCabinetPlacements,
+    },
+    {
+        name: 'project_ai_canvas_elevation_run',
+        description: 'Decompose dimensioned elevation runs into individual cabinets and write one placement rectangle per cabinet. ' +
+            'Use this whenever an elevation run could contain more than one cabinet (almost always): it forces you to ' +
+            'enumerate each cabinet with its width and front type so a multi-cabinet run is never collapsed into one box. ' +
+            AI_ELEVATION_RUN_SEGMENTATION_GUIDANCE,
+        inputSchema: exports.ProjectAiCanvasElevationRunInputSchema,
+        handler: projectAiCanvasElevationRun,
+    },
     {
         name: 'replace_ai_cabinet_coordinates',
         description: 'Replace all backend-owned AIDrawingTool cabinet coordinates for a session. ' +