@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/fence/geometry.d.ts

@@ -1,6 +1,5 @@
-import { type GeometryContext } from '@pascal-app/core';
+import { type FenceWithFeatures, type GeometryContext } from '@pascal-app/core';
 import { type ColorPreset, type RenderShading } from '@pascal-app/viewer';
 import { Group } from 'three';
-import type { FenceNode } from './schema';
-export declare function buildFenceGeometry(node: FenceNode, ctx?: GeometryContext, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string): Group;
+export declare function buildFenceGeometry(node: FenceWithFeatures, ctx?: GeometryContext, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string, mode?: 'body' | 'features'): Group;
 //# sourceMappingURL=geometry.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/fence/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,eAAe,EAA0B,MAAM,kBAAkB,CAAA;AAC/F,OAAO,EAEL,KAAK,WAAW,EAKhB,KAAK,aAAa,EAGnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAa,KAAK,EAAqC,MAAM,OAAO,CAAA;AAE3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAwFzC,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,SAAS,EACf,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,KAAK,CA0CP"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/fence/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,iBAAiB,EAGtB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAEL,KAAK,WAAW,EAIhB,KAAK,aAAa,EAGnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAa,KAAK,EAAqC,MAAM,OAAO,CAAA;AAkH3E,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,iBAAiB,EACvB,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,EACnB,IAAI,GAAE,MAAM,GAAG,UAAmB,GACjC,KAAK,CAwIP"}

package/dist/fence/geometry.js

@@ -1,10 +1,28 @@
-import { getMaterialPresetByRef } from '@pascal-app/core';
-import { applyMaterialPresetToMaterials, createDefaultMaterial, createMaterial, createSurfaceRoleMaterial, generateFenceSlotGeometries, resolveMaterialRef, resolveSlotDefaultMaterial, } from '@pascal-app/viewer';
+import { FENCE_SLOT_DEFAULTS, fenceWithFeatures, floorConstructionLift, getMaterialPresetByRef, liftedManualSlab, plateLevelContext, } from '@pascal-app/core';
+import { applyMaterialPresetToMaterials, createDefaultMaterial, createMaterial, createSurfaceRoleMaterial, resolveMaterialRef, resolveSlotDefaultMaterial, } from '@pascal-app/viewer';
 import { FrontSide, Group, Mesh } from 'three';
-import { resolveFenceLiftElevation } from './lift';
-import { FENCE_SLOT_DEFAULTS } from './slots';
+import { generateFenceSlotGeometries, } from './geometry-parts.js';
+import { resolveFenceLiftElevation } from './lift.js';
 const FENCE_SLOT_ORDER = ['posts', 'infill', 'base', 'rail'];
 const fenceMaterialCache = new Map();
+function sharedFenceCorners(node, siblings) {
+    const omitted = new Set();
+    const neighbors = {};
+    for (const sibling of siblings) {
+        if (sibling.type !== 'fence' || sibling.visible === false)
+            continue;
+        for (const endpoint of ['start', 'end']) {
+            const point = node[endpoint];
+            if (![sibling.start, sibling.end].some((other) => Math.hypot(point[0] - other[0], point[1] - other[1]) < 0.001))
+                continue;
+            if (sibling.height > node.height || (sibling.height === node.height && sibling.id < node.id))
+                omitted.add(endpoint);
+            if (!neighbors[endpoint])
+                neighbors[endpoint] = sibling;
+        }
+    }
+    return { omittedPosts: omitted, neighbors };
+}
 function getFenceSlotMaterial(node, slotId, shading, textures, colorPreset, sceneTheme, sceneMaterials) {
     if (!textures) {
         return createSurfaceRoleMaterial('joinery', colorPreset, FrontSide, sceneTheme);
@@ -48,9 +66,44 @@ function getLegacyFenceMaterial(node, shading) {
     fenceMaterialCache.set(cacheKey, material);
     return material;
 }
-export function buildFenceGeometry(node, ctx, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
+export function buildFenceGeometry(node, ctx, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme, mode = 'body') {
+    const previewFeatures = node.features ?? [];
+    if (mode === 'body')
+        node = fenceWithFeatures(node, ctx?.children ?? []);
     const group = new Group();
-    const geometries = generateFenceSlotGeometries(node);
+    const nodes = ctx ? (plateLevelContext(ctx.parent, ctx.resolve).nodes ?? {}) : {};
+    const constructionLift = floorConstructionLift(nodes, node);
+    const startGround = (ctx?.levelBaseAt?.(node.start[0], node.start[1]) ?? 0) + constructionLift;
+    const surfaceId = node.supportSurfaceNodeId;
+    const surfaceAt = surfaceId
+        ? (x, z) => ctx?.surfaceHeightAt?.(surfaceId, x, z) ?? null
+        : undefined;
+    const startSurface = surfaceAt?.(node.start[0], node.start[1]) ?? null;
+    const startBase = startSurface ?? startGround;
+    const followsTerrain = (node.path?.length ?? 0) >= 2 || Math.abs(node.curveOffset ?? 0) > 1e-4;
+    const chosenHost = node.surfaceMode === 'selected'
+        ? node.supportSurfaceNodeId
+        : undefined;
+    const sampledSupport = followsTerrain && !node.supportSlabId && ctx?.supportHeightAt
+        ? (x, z) => Math.max(ctx.supportHeightAt(x, z, chosenHost), (ctx.levelBaseAt?.(x, z) ?? 0) + constructionLift)
+        : undefined;
+    const levelHeight = node.surfaceMode === 'level' ? sampledSupport?.(node.start[0], node.start[1]) : undefined;
+    const supportAt = levelHeight !== undefined ? () => levelHeight : sampledSupport;
+    const sampledStart = supportAt?.(node.start[0], node.start[1]) ?? startBase;
+    const sampledGround = new Map();
+    const corners = mode === 'body' && ctx ? sharedFenceCorners(node, ctx.siblings) : undefined;
+    const gateLeaves = [];
+    const geometries = generateFenceSlotGeometries(node, supportAt
+        ? (x, z) => {
+            const key = `${x},${z}`;
+            const cached = sampledGround.get(key);
+            if (cached !== undefined)
+                return cached;
+            const height = supportAt(x, z) - sampledStart;
+            sampledGround.set(key, height);
+            return height;
+        }
+        : undefined, mode, corners?.omittedPosts, corners?.neighbors, mode === 'features' ? gateLeaves : undefined);
     // A hosted railing (`supportSlabId`) stands on its slab's walking surface;
     // an unhosted one stands on the ground, which `ctx.levelBaseAt` resolves at
     // the fence's own start point — the anchor its plan geometry is measured
@@ -58,9 +111,17 @@ export function buildFenceGeometry(node, ctx, shading = 'rendered', textures = t
     // is under this fence. The builder emits local-space children, so the lift
     // lives on an inner group rather than the registered (React-transformed)
     // root.
-    const lift = ctx
-        ? resolveFenceLiftElevation(node, (id) => ctx.resolve(id), ctx.levelBaseAt?.(node.start[0], node.start[1]) ?? 0)
+    const baseLift = ctx
+        ? resolveFenceLiftElevation(node, (id) => {
+            const host = ctx.resolve(id);
+            return host?.type === 'slab' ? liftedManualSlab(nodes, host) : host;
+        }, startGround, nodes)
         : 0;
+    const lift = supportAt
+        ? sampledStart + (node.supportOffset ?? 0)
+        : startSurface !== null && !node.supportSlabId
+            ? startSurface + (node.supportOffset ?? 0)
+            : baseLift;
     const meshParent = new Group();
     meshParent.position.y = lift;
     group.add(meshParent);
@@ -75,5 +136,21 @@ export function buildFenceGeometry(node, ctx, shading = 'rendered', textures = t
         mesh.userData.slotId = slotId;
         meshParent.add(mesh);
     }
+    for (const leaf of gateLeaves) {
+        const pivot = new Group();
+        pivot.position.set(leaf.hinge.x, 0, leaf.hinge.z);
+        pivot.rotation.y = leaf.rotationY;
+        pivot.userData.pascalFenceGateLeaf = { openRotationY: leaf.openRotationY };
+        const mesh = new Mesh(leaf.geometry, getFenceSlotMaterial(node, 'infill', shading, textures, colorPreset, sceneTheme, ctx?.materials));
+        mesh.position.set(-leaf.hinge.x, 0, -leaf.hinge.z);
+        mesh.castShadow = true;
+        mesh.receiveShadow = true;
+        mesh.userData.slotId = 'infill';
+        pivot.add(mesh);
+        meshParent.add(pivot);
+    }
+    if (mode === 'body' && previewFeatures.length > 0) {
+        group.add(buildFenceGeometry({ ...node, features: previewFeatures }, ctx, shading, textures, colorPreset, sceneTheme, 'features'));
+    }
     return group;
 }

package/dist/fence/index.d.ts

@@ -1,3 +1,4 @@
-export { fenceDefinition } from './definition';
-export { FenceNode } from './schema';
+export { fenceDefinition } from './definition.js';
+export { beginFenceFeaturePlacement } from './features.js';
+export { FenceNode } from './schema.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/fence/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fence/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fence/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAA;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA"}

package/dist/fence/index.js

@@ -1,2 +1,3 @@
-export { fenceDefinition } from './definition';
-export { FenceNode } from './schema';
+export { fenceDefinition } from './definition.js';
+export { beginFenceFeaturePlacement } from './features.js';
+export { FenceNode } from './schema.js';

package/dist/fence/inspector-editors.d.ts

@@ -1,4 +1,15 @@
 import { type FenceNode } from '@pascal-app/core';
+export declare function FencePatternInfo({ node }: {
+    node: FenceNode;
+}): import("react").JSX.Element;
+export declare function FencePicketRailProjectionEditor({ node, onUpdate, }: {
+    node: FenceNode;
+    onUpdate: (patch: Partial<FenceNode>) => void;
+}): import("react").JSX.Element;
+export declare function FenceSurfaceEditor({ node, onUpdate, }: {
+    node: FenceNode;
+    onUpdate: (patch: Partial<FenceNode>) => void;
+}): import("react").JSX.Element;
 /**
  * Custom inspector editors for fence fields that don't map to a single
  * node property in the canonical way:
@@ -21,4 +32,8 @@ export declare function FenceCurveEditor({ node, onUpdate, }: {
     node: FenceNode;
     onUpdate: (patch: Partial<FenceNode>) => void;
 }): import("react").JSX.Element;
+export declare function FencePathEditor({ node, onUpdate, }: {
+    node: FenceNode;
+    onUpdate: (patch: Partial<FenceNode>) => void;
+}): import("react").JSX.Element;
 //# sourceMappingURL=inspector-editors.d.ts.map

package/dist/fence/inspector-editors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inspector-editors.d.ts","sourceRoot":"","sources":["../../src/fence/inspector-editors.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,SAAS,EAKf,MAAM,kBAAkB,CAAA;AAGzB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,SAAS,CAAA;IACf,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,KAAK,IAAI,CAAA;CAC9C,+BA8BA;AAED,wBAAgB,gBAAgB,CAAC,EAC/B,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,SAAS,CAAA;IACf,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,KAAK,IAAI,CAAA;CAC9C,+BAgBA"}
+{"version":3,"file":"inspector-editors.d.ts","sourceRoot":"","sources":["../../src/fence/inspector-editors.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,SAAS,EAgBf,MAAM,kBAAkB,CAAA;AAGzB,wBAAgB,gBAAgB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,+BAa7D;AAED,wBAAgB,+BAA+B,CAAC,EAC9C,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,SAAS,CAAA;IACf,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,KAAK,IAAI,CAAA;CAC9C,+BAgBA;AAED,wBAAgB,kBAAkB,CAAC,EACjC,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,SAAS,CAAA;IACf,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,KAAK,IAAI,CAAA;CAC9C,+BAqEA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,SAAS,CAAA;IACf,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,KAAK,IAAI,CAAA;CAC9C,+BA8BA;AAED,wBAAgB,gBAAgB,CAAC,EAC/B,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,SAAS,CAAA;IACf,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,KAAK,IAAI,CAAA;CAC9C,+BA6CA;AAED,wBAAgB,eAAe,CAAC,EAC9B,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,SAAS,CAAA;IACf,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,KAAK,IAAI,CAAA;CAC9C,+BAyKA"}

package/dist/fence/inspector-editors.js

@@ -1,7 +1,49 @@
 'use client';
-import { jsx as _jsx } from "react/jsx-runtime";
-import { getClampedWallCurveOffset, getMaxWallCurveOffset, getWallCurveLength, normalizeWallCurveOffset, } from '@pascal-app/core';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { clampFencePicketRailProjection, findLevelAncestorId, getClampedWallCurveOffset, getFenceCenterlineLength, getFenceControlHandle, getFenceSpanMode, getMaxWallCurveOffset, getTwoPointFenceCurveTangents, getWallArcData, getWallCurveFrameAt, getWallCurveLength, maxFencePicketRailProjection, nodeRegistry, normalizeWallCurveOffset, sampleFenceSpline, useScene, } from '@pascal-app/core';
 import { SliderControl } from '@pascal-app/editor';
+export function FencePatternInfo({ node }) {
+    const subject = node.style === 'picket'
+        ? 'pickets in each bay between posts'
+        : node.style === 'horizontal'
+            ? 'posts along the full fence'
+            : 'infill pieces between the two end posts';
+    return (_jsxs("p", { className: "text-xs text-muted-foreground", children: ["Distribution controls ", subject, ". Spacing is measured between centers. The available width limits the count so pieces do not overlap."] }));
+}
+export function FencePicketRailProjectionEditor({ node, onUpdate, }) {
+    const max = maxFencePicketRailProjection(node.postSize);
+    return (_jsx(SliderControl, { label: "Picket rail projection", max: max, min: 0.001, onChange: (value) => onUpdate({ picketRailProjection: clampFencePicketRailProjection(value, node.postSize) }), precision: 3, step: 0.002, unit: "m", value: clampFencePicketRailProjection(node.picketRailProjection, node.postSize) }));
+}
+export function FenceSurfaceEditor({ node, onUpdate, }) {
+    const nodes = useScene((state) => state.nodes);
+    const levelId = findLevelAncestorId(node.id, nodes);
+    const hosts = Object.values(nodes).filter((candidate) => candidate.id !== node.id &&
+        candidate.visible !== false &&
+        (candidate.type === 'slab' ||
+            !!nodeRegistry.get(candidate.type)?.capabilities.surfaces?.top) &&
+        findLevelAncestorId(candidate.id, nodes) === levelId);
+    const selectedId = node.supportSurfaceNodeId ?? node.supportSlabId ?? '';
+    return (_jsxs("div", { className: "space-y-2 text-xs", children: [_jsxs("label", { className: "flex items-center justify-between gap-2", children: ["Surface behavior", _jsxs("select", { className: "rounded border bg-background p-1", value: node.surfaceMode, onChange: (event) => {
+                            const mode = event.target.value;
+                            if (mode === 'selected' && !selectedId && hosts[0]) {
+                                const host = hosts[0];
+                                onUpdate({
+                                    surfaceMode: mode,
+                                    supportSlabId: host.type === 'slab' ? host.id : undefined,
+                                    supportSurfaceNodeId: host.type === 'slab' ? undefined : host.id,
+                                });
+                            }
+                            else {
+                                onUpdate({ surfaceMode: mode });
+                            }
+                        }, children: [_jsx("option", { value: "auto", children: "Follow highest surface" }), _jsx("option", { disabled: hosts.length === 0, value: "selected", children: "Follow selected surface" }), _jsx("option", { value: "level", children: "Hold starting height" })] })] }), node.surfaceMode === 'selected' && (_jsxs("label", { className: "flex items-center justify-between gap-2", children: ["Surface", _jsxs("select", { className: "min-w-0 max-w-40 rounded border bg-background p-1", value: selectedId, onChange: (event) => {
+                            const host = nodes[event.target.value];
+                            onUpdate({
+                                supportSlabId: host?.type === 'slab' ? host.id : undefined,
+                                supportSurfaceNodeId: host && host.type !== 'slab' ? host.id : undefined,
+                            });
+                        }, children: [_jsx("option", { value: "", children: "Choose a surface" }), hosts.map((host) => (_jsxs("option", { value: host.id, children: [host.name || host.type, " (", host.type, ")"] }, host.id)))] })] })), node.surfaceMode === 'selected' && !selectedId && (_jsx("p", { className: "text-muted-foreground", children: "Choose a slab or shaped surface on this level." }))] }));
+}
 /**
  * Custom inspector editors for fence fields that don't map to a single
  * node property in the canonical way:
@@ -39,5 +81,88 @@ export function FenceLengthEditor({ node, onUpdate, }) {
 export function FenceCurveEditor({ node, onUpdate, }) {
     const curveOffset = getClampedWallCurveOffset(node);
     const maxCurveOffset = getMaxWallCurveOffset(node);
-    return (_jsx(SliderControl, { label: "Curve", max: Math.max(0.01, maxCurveOffset), min: -Math.max(0.01, maxCurveOffset), onChange: (value) => onUpdate({ curveOffset: normalizeWallCurveOffset(node, value) }), precision: 2, step: 0.1, unit: "m", value: curveOffset }));
+    return (_jsxs("div", { className: "space-y-2", children: [_jsx(SliderControl, { label: "Curve", max: Math.max(0.01, maxCurveOffset), min: -Math.max(0.01, maxCurveOffset), onChange: (value) => onUpdate({ curveOffset: normalizeWallCurveOffset(node, value) }), precision: 2, step: 0.1, unit: "m", value: curveOffset }), _jsx("button", { type: "button", className: "rounded border px-2 py-1 text-xs", onClick: () => {
+                    const arc = getWallArcData(node);
+                    const spans = arc ? 4 : 1;
+                    const handleLength = arc
+                        ? (4 / 3) * arc.radius * Math.tan(Math.abs(arc.delta) / spans / 4)
+                        : getWallCurveLength(node) / 3;
+                    const frames = Array.from({ length: spans + 1 }, (_, i) => getWallCurveFrameAt(node, i / spans));
+                    onUpdate({
+                        path: frames.map((frame) => [frame.point.x, frame.point.y]),
+                        spanModes: Array.from({ length: spans }, () => arc ? 'curve' : 'straight'),
+                        tangents: frames.map((frame) => [
+                            frame.tangent.x * handleLength,
+                            frame.tangent.y * handleLength,
+                        ]),
+                        curveOffset: undefined,
+                    });
+                }, children: "Edit path" })] }));
+}
+export function FencePathEditor({ node, onUpdate, }) {
+    const path = node.path ?? [];
+    const tangents = path.map((_, i) => node.tangents?.[i] ?? null);
+    const spanModes = path
+        .slice(1)
+        .map((_, i) => getFenceSpanMode(path, node.tangents, node.spanModes, i));
+    const update = (points, handles = tangents, modes = spanModes) => {
+        if (points.length < 2)
+            return;
+        onUpdate({
+            path: points,
+            tangents: handles,
+            spanModes: modes,
+            start: points[0],
+            end: points.at(-1),
+        });
+    };
+    return (_jsxs("div", { className: "space-y-2 text-xs", children: [_jsxs("p", { children: [path.length, " points \u00B7 ", getFenceCenterlineLength(node).toFixed(2), " m"] }), _jsx("p", { className: "text-muted-foreground", children: "Set each span to straight or curved, then drag its points and curve handles in either view." }), path.map((point, index) => (_jsxs("details", { className: "rounded border p-2", children: [_jsxs("summary", { className: "cursor-pointer", children: ["Point ", index + 1] }), _jsx("div", { className: "mt-2 flex gap-2", children: ['X', 'Z'].map((axis, coordinate) => (_jsxs("label", { className: "min-w-0 flex-1", children: [axis, " (m)", _jsx("input", { type: "number", step: "0.05", className: "w-full rounded border bg-transparent p-1", defaultValue: point[coordinate], onBlur: (event) => {
+                                        const value = event.currentTarget.valueAsNumber;
+                                        if (!Number.isFinite(value) || value === point[coordinate])
+                                            return;
+                                        update(path.map((p, i) => i === index ? (coordinate === 0 ? [value, p[1]] : [p[0], value]) : p));
+                                    } }, `${index}-${axis}-${point[coordinate]}`)] }, axis))) }), index < path.length - 1 && (_jsxs("label", { className: "mt-2 flex items-center justify-between", children: ["Span to point ", index + 2, _jsxs("select", { className: "rounded border bg-background p-1", value: spanModes[index], onChange: (event) => {
+                                    const modes = [...spanModes];
+                                    modes[index] = event.target.value;
+                                    const handles = path.length === 2 && modes[index] === 'curve' && spanModes[index] === 'straight'
+                                        ? (getTwoPointFenceCurveTangents(path) ?? tangents)
+                                        : tangents;
+                                    update(path, handles, modes);
+                                }, children: [_jsx("option", { value: "straight", children: "Straight" }), _jsx("option", { value: "curve", children: "Curved" })] })] })), (spanModes[index - 1] === 'curve' || spanModes[index] === 'curve') && (_jsxs("label", { className: "mt-2 flex items-center justify-between", children: ["Join", _jsxs("select", { className: "rounded border bg-background p-1", value: tangents[index]?.[0] === 0 && tangents[index]?.[1] === 0 ? 'corner' : 'smooth', onChange: (event) => {
+                                    const handles = [...tangents];
+                                    handles[index] = event.target.value === 'corner' ? [0, 0] : null;
+                                    update(path, handles);
+                                }, children: [_jsx("option", { value: "smooth", children: "Smooth" }), _jsx("option", { value: "corner", children: "Corner" })] })] })), _jsxs("div", { className: "mt-2 flex gap-2", children: [index < path.length - 1 && (_jsx("button", { type: "button", className: "rounded border px-2 py-1", onClick: () => {
+                                    const a = getFenceControlHandle(path, node.tangents, index);
+                                    const b = getFenceControlHandle(path, node.tangents, index + 1);
+                                    const samples = sampleFenceSpline([point, path[index + 1]], [
+                                        [a.x, a.y],
+                                        [b.x, b.y],
+                                    ], 2, [spanModes[index]]);
+                                    const midpoint = samples[1];
+                                    const points = [...path];
+                                    points.splice(index + 1, 0, [midpoint.x, midpoint.y]);
+                                    const handles = [...tangents];
+                                    handles.splice(index + 1, 0, null);
+                                    const modes = [...spanModes];
+                                    modes.splice(index, 1, spanModes[index], spanModes[index]);
+                                    update(points, handles, modes);
+                                }, children: "Add point after" })), index === path.length - 1 && (_jsx("button", { type: "button", className: "rounded border px-2 py-1", onClick: () => {
+                                    const previous = path[index - 1];
+                                    update([
+                                        ...path,
+                                        [point[0] + point[0] - previous[0], point[1] + point[1] - previous[1]],
+                                    ], [...tangents, null], [...spanModes, 'straight']);
+                                }, children: "Extend path" })), _jsx("button", { type: "button", className: "rounded border px-2 py-1 disabled:opacity-40", disabled: path.length <= 2, onClick: () => {
+                                    const modes = [...spanModes];
+                                    if (index === 0)
+                                        modes.shift();
+                                    else if (index === path.length - 1)
+                                        modes.pop();
+                                    else
+                                        modes.splice(index - 1, 2, spanModes[index - 1] === 'straight' && spanModes[index] === 'straight'
+                                            ? 'straight'
+                                            : 'curve');
+                                    update(path.filter((_, i) => i !== index), tangents.filter((_, i) => i !== index), modes);
+                                }, children: "Remove point" })] })] }, `curve-editor-${index}`)))] }));
 }

package/dist/fence/lift.d.ts

@@ -1,5 +1,5 @@
 import { type AnyNode } from '@pascal-app/core';
-import type { FenceNode } from './schema';
+import type { FenceNode } from './schema.js';
 /**
  * Elevation (meters above the level plane) a hosted fence stands at.
  *
@@ -21,7 +21,7 @@ import type { FenceNode } from './schema';
  * exists wins outright, so a railing on a deck pad keeps the pad's elevation
  * instead of following the hillside around it.
  */
-export declare function resolveFenceLiftElevation(node: Pick<FenceNode, 'supportSlabId' | 'supportOffset' | 'parentId'>, resolve: (id: string) => AnyNode | undefined, levelBase?: number): number;
+export declare function resolveFenceLiftElevation(node: Pick<FenceNode, 'supportSlabId' | 'supportSurfaceNodeId' | 'supportOffset' | 'parentId'>, resolve: (id: string) => AnyNode | undefined, levelBase?: number, nodes?: Record<string, AnyNode>): number;
 /**
  * {@link resolveFenceLiftElevation} against a nodes record, with the level base
  * resolved from the terrain under the fence's start point — the same anchor the
@@ -34,5 +34,5 @@ export declare function resolveFenceLiftElevation(node: Pick<FenceNode, 'support
  * using the pure form, since `GeometryContext` deliberately exposes the ground
  * as a closure rather than the store.
  */
-export declare function resolveFenceLiftElevationForNodes(node: Pick<FenceNode, 'id' | 'start' | 'supportSlabId' | 'supportOffset' | 'parentId'>, nodes: Record<string, AnyNode>): number;
+export declare function resolveFenceLiftElevationForNodes(node: Pick<FenceNode, 'id' | 'start' | 'supportSlabId' | 'supportSurfaceNodeId' | 'supportOffset' | 'parentId'>, nodes: Record<string, AnyNode>): number;
 //# sourceMappingURL=lift.d.ts.map

package/dist/fence/lift.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lift.d.ts","sourceRoot":"","sources":["../../src/fence/lift.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAKb,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,eAAe,GAAG,eAAe,GAAG,UAAU,CAAC,EACrE,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,EAC5C,SAAS,SAAI,GACZ,MAAM,CAQR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,GAAG,OAAO,GAAG,eAAe,GAAG,eAAe,GAAG,UAAU,CAAC,EACtF,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,CAIR"}
+{"version":3,"file":"lift.d.ts","sourceRoot":"","sources":["../../src/fence/lift.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAQb,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,eAAe,GAAG,sBAAsB,GAAG,eAAe,GAAG,UAAU,CAAC,EAC9F,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,EAC5C,SAAS,SAAI,EACb,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAClC,MAAM,CAiBR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,IAAI,CACR,SAAS,EACT,IAAI,GAAG,OAAO,GAAG,eAAe,GAAG,sBAAsB,GAAG,eAAe,GAAG,UAAU,CACzF,EACD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,CAYR"}

package/dist/fence/lift.js

@@ -1,4 +1,4 @@
-import { findLevelAncestorId, levelBaseElevationAt, } from '@pascal-app/core';
+import { findLevelAncestorId, floorConstructionLift, levelBaseElevationAt, liftedManualSlab, nodeRegistry, } from '@pascal-app/core';
 /**
  * Elevation (meters above the level plane) a hosted fence stands at.
  *
@@ -20,8 +20,17 @@ import { findLevelAncestorId, levelBaseElevationAt, } from '@pascal-app/core';
  * exists wins outright, so a railing on a deck pad keeps the pad's elevation
  * instead of following the hillside around it.
  */
-export function resolveFenceLiftElevation(node, resolve, levelBase = 0) {
+export function resolveFenceLiftElevation(node, resolve, levelBase = 0, nodes = {}) {
     const offset = node.supportOffset ?? 0;
+    if (node.supportSurfaceNodeId) {
+        const surface = resolve(node.supportSurfaceNodeId);
+        const top = surface && nodeRegistry.get(surface.type)?.capabilities?.surfaces?.top;
+        if (surface && top && surface.parentId === node.parentId) {
+            const height = typeof top.height === 'function' ? top.height(surface, { nodes }) : top.height;
+            const position = surface.position;
+            return (position?.[1] ?? 0) + height + floorConstructionLift(nodes, surface) + offset;
+        }
+    }
     if (!node.supportSlabId)
         return levelBase + offset;
     const host = resolve(node.supportSlabId);
@@ -47,5 +56,8 @@ export function resolveFenceLiftElevation(node, resolve, levelBase = 0) {
 export function resolveFenceLiftElevationForNodes(node, nodes) {
     const levelId = findLevelAncestorId(node.id, nodes);
     const levelBase = levelId ? levelBaseElevationAt(nodes, levelId, node.start[0], node.start[1]) : 0;
-    return resolveFenceLiftElevation(node, (id) => nodes[id], levelBase);
+    return resolveFenceLiftElevation(node, (id) => {
+        const host = nodes[id];
+        return host?.type === 'slab' ? liftedManualSlab(nodes, host) : host;
+    }, levelBase + (nodes[node.id] ? floorConstructionLift(nodes, nodes[node.id]) : 0), nodes);
 }

package/dist/fence/move-control-point-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-control-point-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-control-point-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAazB,eAAO,MAAM,yBAAyB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC/C,MAAM,EAAE;QAAE,KAAK,EAAE,SAAS,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;CAC5C,CAuGA,CAAA;AAED,eAAe,yBAAyB,CAAA"}
+{"version":3,"file":"move-control-point-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-control-point-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAazB,eAAO,MAAM,yBAAyB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC/C,MAAM,EAAE;QAAE,KAAK,EAAE,SAAS,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;CAC5C,CAuGA,CAAA;eAEc,yBAAyB"}

package/dist/fence/move-endpoint-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-endpoint-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-endpoint-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EAKf,MAAM,kBAAkB,CAAA;AAkBzB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,SAAS,CAAA;IAChB,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;CAC1B,CAAA;AAgDD,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,MAAM,EAAE,mBAAmB,CAAA;CAAE,CA0M3E,CAAA;AAED,eAAe,qBAAqB,CAAA"}
+{"version":3,"file":"move-endpoint-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-endpoint-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EAKf,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,SAAS,CAAA;IAChB,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;CAC1B,CAAA;AAgDD,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,MAAM,EAAE,mBAAmB,CAAA;CAAE,CA0M3E,CAAA;eAEc,qBAAqB"}

package/dist/fence/move-endpoint-tool.js

@@ -1,11 +1,11 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { emitter, getWallCurveLength, useScene, } from '@pascal-app/core';
-import { CursorSphere, formatAngleRadians, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, MeasurementPill, triggerSFX, useAlignmentGuides, useDragAction, useInteractionScope, } from '@pascal-app/editor';
+import { CursorSphere, formatAngleRadians, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isTypingTarget, MeasurementPill, triggerSFX, useAlignmentGuides, useDragAction, useInteractionScope, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { useEffect, useMemo, useRef, useState } from 'react';
-import { moveFenceEndpointDragAction } from './actions/move-endpoint';
+import { moveFenceEndpointDragAction } from './actions/move-endpoint.js';
 function referenceSegments(walls, fences) {
     return [
         ...walls.map((w) => ({ id: w.id, start: w.start, end: w.end, curveOffset: w.curveOffset })),
@@ -153,7 +153,7 @@ export const MoveFenceEndpointTool = ({ target }) => {
     // event modifiers so the badge can toggle without a pointer move.
     useEffect(() => {
         const onKeyDown = (e) => {
-            if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement)
+            if (isTypingTarget(e.target))
                 return;
             if (e.key === 'Alt')
                 setAltPressed(true);
@@ -184,7 +184,7 @@ export const MoveFenceEndpointTool = ({ target }) => {
     const dimMidX = (liveStart[0] + liveEnd[0]) / 2;
     const dimMidZ = (liveStart[1] + liveEnd[1]) / 2;
     return (_jsxs("group", { children: [_jsx(CursorSphere, { position: cursorPos, showTooltip: false }), _jsx(Html, { center: true, position: [dimMidX, fenceHeight + 0.3, dimMidZ], style: { pointerEvents: 'none', touchAction: 'none' }, zIndexRange: [100, 0], children: _jsx(MeasurementPill, { height: fenceHeight, length: liveLength, primary: "length", thickness: target.fence.thickness ?? 0.08, unit: unit }) }), _jsx(Html, { position: cursorPos, style: { pointerEvents: 'none', touchAction: 'none' }, zIndexRange: [100, 0], children: _jsx("div", { className: "translate-y-10", children: _jsx("div", { className: `whitespace-nowrap rounded-full border px-2 py-1 font-medium text-[11px] shadow-lg backdrop-blur-md transition-colors ${altPressed
-                            ? 'border-amber-500/70 bg-amber-500/15 text-amber-100'
+                            ? 'border-amber-500/70 bg-amber-50/95 text-amber-800 dark:bg-amber-500/15 dark:text-amber-100'
                             : 'border-border/70 bg-background/90 text-foreground/80'}`, children: altPressed ? 'Detach endpoint' : 'Drag endpoint' }) }) }), angleLabel && (_jsx(Html, { center: true, position: angleLabel.position, style: { pointerEvents: 'none' }, zIndexRange: [100, 0], children: _jsx("div", { className: "whitespace-nowrap rounded-full border border-border bg-background/95 px-2 py-1 font-mono font-semibold text-[11px] text-foreground shadow-lg backdrop-blur-md", children: angleLabel.label }) }))] }));
 };
 export default MoveFenceEndpointTool;

package/dist/fence/move-tangent-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tangent-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-tangent-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAezB,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC1C,MAAM,EAAE;QAAE,KAAK,EAAE,SAAS,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,IAAI,GAAG,KAAK,CAAA;KAAE,CAAA;CAChE,CAwGA,CAAA;AAED,eAAe,oBAAoB,CAAA"}
+{"version":3,"file":"move-tangent-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-tangent-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAezB,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC1C,MAAM,EAAE;QAAE,KAAK,EAAE,SAAS,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,IAAI,GAAG,KAAK,CAAA;KAAE,CAAA;CAChE,CAwGA,CAAA;eAEc,oBAAoB"}

package/dist/fence/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAWf,MAAM,kBAAkB,CAAA;AAsHzB,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAgSvD,CAAA;AAED,eAAe,aAAa,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAWf,MAAM,kBAAkB,CAAA;AAsHzB,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAgSvD,CAAA;eAEc,aAAa"}

package/dist/fence/move-tool.js

@@ -1,9 +1,10 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { constrainWallMoveDeltaToAxis, emitter, getPerpendicularWallMoveAxis, isCurvedWall, isSplineFence, resolveFenceSupportSlabPatch, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { CursorSphere, consumePlacementDragRelease, getSegmentGridStep, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, snapFenceDraftPoint, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { CursorSphere, consumePlacementDragRelease, getSegmentGridStep, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useCallback, useEffect, useRef, useState } from 'react';
+import { snapFenceDraftPoint } from './drafting.js';
 /**
  * Phase 5 Stage D — fence whole-move tool.
  *

package/dist/fence/paint.js

@@ -1,4 +1,4 @@
-import { createSlotPaintCapability, previewGeometrySlot } from '../shared/slot-paint';
+import { createSlotPaintCapability, previewGeometrySlot } from '../shared/slot-paint.js';
 const FENCE_SLOT_IDS = new Set(['posts', 'infill', 'base', 'rail']);
 function resolveFenceRole(args) {
     const slotId = args.hitObject?.userData?.slotId;

package/dist/fence/panel-model.d.ts

@@ -0,0 +1,4 @@
+import type { FenceNode } from '@pascal-app/core';
+import type { NodePanelModel } from '@pascal-app/editor';
+export declare const fencePanelModel: NodePanelModel<FenceNode>;
+//# sourceMappingURL=panel-model.d.ts.map

package/dist/fence/panel-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel-model.d.ts","sourceRoot":"","sources":["../../src/fence/panel-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAGxD,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,SAAS,CAUrD,CAAA"}

package/dist/fence/panel-model.js

@@ -0,0 +1,12 @@
+import { beginFenceFeaturePlacement } from './features.js';
+export const fencePanelModel = {
+    rows() {
+        return ['gate', 'opening'].map((kind) => ({
+            id: `add-${kind}`,
+            kind: 'action',
+            section: 'Gates & openings',
+            label: kind === 'gate' ? 'Add Gate' : 'Add Opening',
+            onSelect: () => beginFenceFeaturePlacement(kind),
+        }));
+    },
+};

package/dist/fence/parametrics.d.ts

@@ -1,16 +1,4 @@
 import { type ParametricDescriptor } from '@pascal-app/core';
-import type { FenceNode } from './schema';
-/**
- * Inspector descriptor for fence. Mirrors the legacy `FencePanel`
- * layout 1:1:
- *  - **Style** (segmented controls): style, baseStyle, showInfill toggle.
- *  - **Dimensions**: Length (derived from start/end), Curve (sagitta
- *    with dynamic bounds), Height, Thickness.
- *  - **Structure**: Base Height, Top Rail, Post Spacing, Post Size,
- *    Post Cap + Slat Gap (horizontal-only), Ground Clear, Edge Inset.
- *
- * Length + Curve use the `custom` field kind because they don't map
- * to single number fields with static bounds — see `inspector-editors.tsx`.
- */
+import type { FenceNode } from './schema.js';
 export declare const fenceParametrics: ParametricDescriptor<FenceNode>;
 //# sourceMappingURL=parametrics.d.ts.map

package/dist/fence/parametrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/fence/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAE3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,EAAE,oBAAoB,CAAC,SAAS,CAuE5D,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/fence/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,kBAAkB,CAAA;AASzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC,eAAO,MAAM,gBAAgB,EAAE,oBAAoB,CAAC,SAAS,CA4P5D,CAAA"}