@pascal-app/nodes 0.1.1

package/dist/item/floorplan.js

@@ -0,0 +1,204 @@
+import { getRoofWallFaceFrame, getScaledDimensions, roofFacePointToSegment, useLiveTransforms, } from '@pascal-app/core';
+// Plan-space rotation convention used by the legacy `rotatePlanVector`
+// in `editor/src/lib/floorplan/geometry.ts`. This is a CLOCKWISE rotation
+// — the registry-side equivalent of the canonical floor-plan transform
+// math. Don't switch to a standard counter-clockwise rotation; the wall
+// items math (wallRotation = -atan2(dy, dx)) is calibrated against this
+// convention, and the legacy item floor-plan stack reads from these
+// offsets across many sites.
+function rotateVec(x, y, angle) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return [x * c + y * s, -x * s + y * c];
+}
+function resolveItemTransform(item, ctx, cache = new Map()) {
+    const cached = cache.get(item.id);
+    if (cached !== undefined)
+        return cached;
+    const localRotation = item.rotation[1] ?? 0;
+    let result = null;
+    const parentNode = item.parentId
+        ? ctx.resolve(item.parentId)
+        : undefined;
+    if (parentNode?.type === 'wall') {
+        // Wall-aligned: rotate item.position by wall's angle, anchor at wall.start.
+        const wall = parentNode;
+        const wallRotation = -Math.atan2(wall.end[1] - wall.start[1], wall.end[0] - wall.start[0]);
+        const wallLocalZ = item.asset.attachTo === 'wall-side'
+            ? ((wall.thickness ?? 0.1) / 2) * (item.side === 'front' ? 1 : -1)
+            : item.position[2];
+        const [offsetX, offsetY] = rotateVec(item.position[0], wallLocalZ, wallRotation);
+        result = {
+            x: wall.start[0] + offsetX,
+            y: wall.start[1] + offsetY,
+            rotation: wallRotation + localRotation,
+        };
+    }
+    else if (parentNode?.type === 'item') {
+        // Nested item: recursively resolve parent's transform.
+        const parentT = resolveItemTransform(parentNode, ctx, cache);
+        if (parentT) {
+            const [offsetX, offsetY] = rotateVec(item.position[0], item.position[2], parentT.rotation);
+            result = {
+                x: parentT.x + offsetX,
+                y: parentT.y + offsetY,
+                rotation: parentT.rotation + localRotation,
+            };
+        }
+    }
+    else if (parentNode?.type === 'shelf') {
+        // Shelf-hosted item: `item.position` is in shelf-local coords. The
+        // shelf has its own `position` + `rotation[1]` in its parent (level)
+        // frame, so the item's plan-space position composes the shelf's
+        // pose with the item's local offset. Without this branch the
+        // `else` below would treat shelf-local coords as level-local and
+        // the item would render at the wrong spot whenever the shelf is
+        // anywhere other than (0, 0, 0).
+        //
+        // We also check `useLiveTransforms` for the shelf — if the shelf is
+        // mid-move (3D or 2D), its scene-state `position` is still at the
+        // pre-move spot but the live transform carries the cursor-tracked
+        // position. Reading the live value here keeps the hosted item
+        // following the shelf in 2D throughout the drag, mirroring how the
+        // shelf's own entry follows via the layer's effectiveNode override.
+        const shelf = parentNode;
+        const live = useLiveTransforms.getState().get(shelf.id);
+        const shelfX = live?.position[0] ?? shelf.position[0];
+        const shelfZ = live?.position[2] ?? shelf.position[2];
+        const shelfRotationY = live?.rotation ?? shelf.rotation[1] ?? 0;
+        const [offsetX, offsetY] = rotateVec(item.position[0], item.position[2], shelfRotationY);
+        result = {
+            x: shelfX + offsetX,
+            y: shelfZ + offsetY,
+            rotation: shelfRotationY + localRotation,
+        };
+    }
+    else if (parentNode?.type === 'roof-segment') {
+        // Roof-hosted wall item: FACE-LOCAL position mapped through the face
+        // frame, then composed through the segment's and parent roof's poses
+        // into level-local plan coords.
+        const segment = parentNode;
+        const roof = segment.parentId
+            ? ctx.resolve(segment.parentId)
+            : undefined;
+        if (roof?.type === 'roof' && item.roofFace) {
+            const frame = getRoofWallFaceFrame(segment, item.roofFace);
+            const segLocal = roofFacePointToSegment(segment, item.roofFace, item.position);
+            const [sx, sz] = rotateVec(segLocal[0], segLocal[2], segment.rotation ?? 0);
+            const [rx, rz] = rotateVec(sx + segment.position[0], sz + segment.position[2], roof.rotation ?? 0);
+            result = {
+                x: rx + roof.position[0],
+                y: rz + roof.position[2],
+                rotation: (roof.rotation ?? 0) + (segment.rotation ?? 0) + frame.yaw + localRotation,
+            };
+        }
+    }
+    else {
+        // Level / slab / ceiling parent — item.position is level-local.
+        result = {
+            x: item.position[0],
+            y: item.position[2],
+            rotation: localRotation,
+        };
+    }
+    cache.set(item.id, result);
+    return result;
+}
+export function buildItemFloorplan(node, ctx) {
+    const transform = resolveItemTransform(node, ctx);
+    if (!transform)
+        return null;
+    const [width, , depth] = getScaledDimensions(node);
+    if (width <= 0 || depth <= 0)
+        return null;
+    // Wall-side items are anchored at the mounted wall face; their body extends
+    // depth-ward AWAY from the wall (into the room), so push the footprint centre
+    // a half-depth out along the item's local +Z. After the front/back π flip in
+    // `transform.rotation`, +depth/2 always points off the wall for either side;
+    // a negative offset would lay the footprint across the wall onto the far side.
+    const centerLocalZ = node.asset.attachTo === 'wall-side' ? depth / 2 : 0;
+    const [centerOffsetX, centerOffsetY] = rotateVec(0, centerLocalZ, transform.rotation);
+    const cx = transform.x + centerOffsetX;
+    const cy = transform.y + centerOffsetY;
+    // Rectangle corners in local space, rotated and translated.
+    const halfW = width / 2;
+    const halfD = depth / 2;
+    const corners = [
+        [-halfW, -halfD],
+        [halfW, -halfD],
+        [halfW, halfD],
+        [-halfW, halfD],
+    ];
+    const points = corners.map(([x, y]) => {
+        const [rx, ry] = rotateVec(x, y, transform.rotation);
+        return [cx + rx, cy + ry];
+    });
+    const isSelected = ctx.viewState?.selected ?? false;
+    // Marquee preview — the about-to-be-selected tint every other kind shows.
+    const isHighlighted = ctx.viewState?.highlighted ?? false;
+    const showSelection = isSelected || isHighlighted;
+    const isMoving = ctx.viewState?.moving ?? false;
+    const selectedStroke = ctx.viewState?.palette?.selectedStroke ?? '#3b82f6';
+    const floorPlanUrl = node.asset.floorPlanUrl;
+    const children = [
+        {
+            kind: 'polygon',
+            points,
+            // When an asset thumbnail is present, the polygon is a transparent
+            // hit-target — the image carries the visual weight. Without a
+            // thumbnail the polygon needs a light fill to read at all.
+            //
+            // `transparent` (not `none`) so the interior remains hit-testable —
+            // the registry layer's wrapping `<g>` only fires onPointerDown when
+            // the child renders a paintable surface. `fill="none"` would make
+            // clicks pass through to whatever's beneath, breaking selection.
+            fill: floorPlanUrl ? 'transparent' : '#fef3c7',
+            // Selected items read as selected: palette stroke + heavier weight
+            // (the move dot used to be the only cue, and it hides in
+            // multi-selections).
+            stroke: showSelection ? selectedStroke : '#92400e',
+            strokeWidth: showSelection ? 0.035 : 0.012,
+            opacity: 0.85,
+        },
+    ];
+    // Asset thumbnail — top-down PNG capture from the asset modal. Drawn
+    // inside the footprint with the item's rotation applied. Matches the
+    // legacy `FloorplanItemImage` overlay.
+    if (floorPlanUrl) {
+        children.push({
+            kind: 'image',
+            url: floorPlanUrl,
+            center: [cx, cy],
+            width,
+            height: depth,
+            // `rotateVec` (the footprint polygon) applies R(-angle), but the renderer
+            // draws the image with SVG `rotate(+deg)` = R(+angle). Negate so the
+            // sprite rotates the same way as its footprint box (and 3D); otherwise the
+            // two counter-rotate and diverge by 2x the item's rotation.
+            rotation: -transform.rotation,
+        });
+    }
+    // Selection ring ABOVE the thumbnail — the base polygon's selected stroke
+    // sits underneath the image, so re-draw it on top. `fill: none` keeps the
+    // ring click-through; the base polygon owns hit-testing.
+    if (showSelection && floorPlanUrl) {
+        children.push({
+            kind: 'polygon',
+            points,
+            fill: 'none',
+            stroke: selectedStroke,
+            strokeWidth: 0.035,
+            opacity: isSelected ? 0.95 : 0.7,
+        });
+    }
+    // Move handle — orange dot at the item center. Only when selected and not
+    // already moving: during a move the dot sits under the cursor, so a release
+    // over it would re-arm the move (and re-enter edit) instead of committing.
+    if (isSelected && !isMoving) {
+        children.push({
+            kind: 'move-handle',
+            point: [cx, cy],
+        });
+    }
+    return { kind: 'group', children };
+}

package/dist/item/index.d.ts

@@ -0,0 +1,3 @@
+export { itemDefinition } from './definition';
+export { ItemNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/item/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA"}

package/dist/item/index.js

@@ -0,0 +1,2 @@
+export { itemDefinition } from './definition';
+export { ItemNode } from './schema';

package/dist/item/model-loader.d.ts

@@ -0,0 +1,18 @@
+import { LoadingManager } from 'three';
+import { type GLTF, GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+export type ItemAssetUnavailable = {
+    message: string;
+    url: string;
+};
+export type ItemModelLoadFailureKind = 'retryable' | 'unavailable' | 'unexpected';
+export declare function classifyItemModelLoadFailure(error: unknown): ItemModelLoadFailureKind;
+export declare function createUnavailableItemGltf(url: string, error: unknown): GLTF;
+export declare function getUnavailableItemAsset(gltf: GLTF): ItemAssetUnavailable | null;
+export declare function cancelItemModelLoad(url: string): void;
+export declare class ItemGLTFLoader extends GLTFLoader {
+    readonly hostManager: LoadingManager;
+    readonly retryDelaysMs: readonly number[];
+    constructor(manager?: LoadingManager, retryDelaysMs?: readonly [1000, 3000]);
+    load(url: string, onLoad: (gltf: GLTF) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): void;
+}
+//# sourceMappingURL=model-loader.d.ts.map

package/dist/item/model-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-loader.d.ts","sourceRoot":"","sources":["../../src/item/model-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgC,cAAc,EAAE,MAAM,OAAO,CAAA;AACpE,OAAO,EAAE,KAAK,IAAI,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAA;AAUhF,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG,WAAW,GAAG,aAAa,GAAG,YAAY,CAAA;AAEjF,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,wBAAwB,CAgBrF;AAED,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAiB3E;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,oBAAoB,GAAG,IAAI,CAO/E;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,QAE9C;AAED,qBAAa,cAAe,SAAQ,UAAU;IAC5C,QAAQ,CAAC,WAAW,EAAE,cAAc,CAAA;IACpC,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAA;gBAE7B,OAAO,CAAC,EAAE,cAAc,EAAE,aAAa,wBAA0B;IAMpE,IAAI,CACX,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,EAC5B,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,EAC3C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GACjC,IAAI;CAwER"}

package/dist/item/model-loader.js

@@ -0,0 +1,131 @@
+import { DefaultLoadingManager, Group, LoadingManager } from 'three';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+const ITEM_ASSET_UNAVAILABLE_KEY = 'pascalItemAssetUnavailable';
+const DEFAULT_RETRY_DELAYS_MS = [1_000, 3_000];
+const itemLoadGenerations = new Map();
+export function classifyItemModelLoadFailure(error) {
+    if (!(error instanceof Error))
+        return 'unexpected';
+    const status = error.response?.status;
+    if (status === 408 ||
+        status === 425 ||
+        status === 429 ||
+        (status !== undefined && status >= 500)) {
+        return 'retryable';
+    }
+    if (status !== undefined && status >= 400 && status < 500)
+        return 'unavailable';
+    if (error instanceof TypeError && /failed to fetch/i.test(error.message))
+        return 'retryable';
+    return 'unexpected';
+}
+export function createUnavailableItemGltf(url, error) {
+    const unavailable = {
+        message: error instanceof Error ? error.message : String(error),
+        url,
+    };
+    const scene = new Group();
+    scene.userData[ITEM_ASSET_UNAVAILABLE_KEY] = unavailable;
+    return {
+        animations: [],
+        asset: { version: '2.0' },
+        cameras: [],
+        parser: null,
+        scene,
+        scenes: [scene],
+        userData: { [ITEM_ASSET_UNAVAILABLE_KEY]: unavailable },
+    };
+}
+export function getUnavailableItemAsset(gltf) {
+    const value = gltf.userData?.[ITEM_ASSET_UNAVAILABLE_KEY];
+    if (!value || typeof value !== 'object')
+        return null;
+    const candidate = value;
+    return typeof candidate.url === 'string' && typeof candidate.message === 'string'
+        ? { url: candidate.url, message: candidate.message }
+        : null;
+}
+export function cancelItemModelLoad(url) {
+    itemLoadGenerations.set(url, (itemLoadGenerations.get(url) ?? 0) + 1);
+}
+export class ItemGLTFLoader extends GLTFLoader {
+    hostManager;
+    retryDelaysMs;
+    constructor(manager, retryDelaysMs = DEFAULT_RETRY_DELAYS_MS) {
+        super(new LoadingManager());
+        this.hostManager = manager ?? DefaultLoadingManager;
+        this.retryDelaysMs = retryDelaysMs;
+    }
+    load(url, onLoad, onProgress, onError) {
+        const generation = itemLoadGenerations.get(url) ?? 0;
+        let retryCount = 0;
+        let finished = false;
+        const wasCancelled = () => (itemLoadGenerations.get(url) ?? 0) !== generation;
+        const cancel = () => {
+            if (finished)
+                return;
+            finished = true;
+            this.hostManager.itemEnd(url);
+        };
+        const complete = (gltf) => {
+            if (finished)
+                return;
+            if (wasCancelled()) {
+                cancel();
+                return;
+            }
+            finished = true;
+            try {
+                onLoad(gltf);
+            }
+            finally {
+                this.hostManager.itemEnd(url);
+            }
+        };
+        const fail = (error) => {
+            if (finished)
+                return;
+            if (wasCancelled()) {
+                cancel();
+                return;
+            }
+            finished = true;
+            try {
+                if (onError)
+                    onError(error);
+                else
+                    console.error(error);
+            }
+            finally {
+                this.hostManager.itemError(url);
+                this.hostManager.itemEnd(url);
+            }
+        };
+        const attempt = () => {
+            if (wasCancelled()) {
+                cancel();
+                return;
+            }
+            super.load(url, complete, onProgress, (error) => {
+                if (wasCancelled()) {
+                    cancel();
+                    return;
+                }
+                const kind = classifyItemModelLoadFailure(error);
+                if (kind === 'unexpected') {
+                    fail(error);
+                    return;
+                }
+                if (kind === 'unavailable' || retryCount >= this.retryDelaysMs.length) {
+                    complete(createUnavailableItemGltf(url, error));
+                    return;
+                }
+                const delay = this.retryDelaysMs[retryCount] ?? 0;
+                retryCount += 1;
+                setTimeout(attempt, delay);
+            });
+        };
+        this.hostManager.itemStart(url);
+        attempt();
+    }
+}

package/dist/item/move-tool.d.ts

@@ -0,0 +1,6 @@
+import { type ItemNode } from '@pascal-app/core';
+export declare function MoveItemTool({ node }: {
+    node: ItemNode;
+}): import("react").JSX.Element;
+export default MoveItemTool;
+//# sourceMappingURL=move-tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/item/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,QAAQ,EAAY,MAAM,kBAAkB,CAAA;AAuG1E,wBAAgB,YAAY,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,+BAsDxD;AAED,eAAe,YAAY,CAAA"}

package/dist/item/move-tool.js

@@ -0,0 +1,150 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useScene } from '@pascal-app/core';
+import { triggerSFX, useDraftNode, useEditor, usePlacementCoordinator, } from '@pascal-app/editor';
+import { Vector3 } from 'three';
+/**
+ * Phase 5 Stage D — item's registry-driven 3D move affordance.
+ *
+ * Replaces the legacy `MoveItemContent` in `editor/src/components/tools/
+ * item/move-tool.tsx`. Behaviour is identical: it adopts the moving node
+ * (or creates a draft for duplicates flagged `isNew`), runs the placement
+ * coordinator with surface strategies for floor / wall / ceiling / item-
+ * surface, and commits via `useScene.updateNode` on click.
+ *
+ * Registered via `def.affordanceTools.move`. The editor's
+ * `MoveTool` dispatcher picks this up through `getRegistryAffordance
+ * Tool('item', 'move')` before its legacy chain reaches `<MoveItemContent>`
+ * — so the legacy fallback can now go away.
+ *
+ * Closes the 2D ↔ 3D coexistence bugs from last session: when both
+ * paths mounted, the legacy mover's `destroy()` would clobber the 2D
+ * commit; with this tool owning the move, only one path is alive at a
+ * time.
+ *
+ * Placement primitives (`useDraftNode`, `usePlacementCoordinator`,
+ * `PlacementState`) are re-exported from `@pascal-app/editor` — same
+ * hooks the legacy code used. When `ItemTool` (item placement, not
+ * move) also ports to `def.tool`, the primitives can be inlined here
+ * and dropped from editor.
+ */
+function getInitialState(node) {
+    const attachTo = node.asset.attachTo;
+    if (attachTo === 'wall' || attachTo === 'wall-side') {
+        if (node.roofSegmentId) {
+            return {
+                surface: 'roof-wall',
+                wallId: null,
+                roofSegmentId: node.roofSegmentId,
+                ceilingId: null,
+                surfaceItemId: null,
+                shelfId: null,
+            };
+        }
+        return {
+            surface: 'wall',
+            wallId: node.parentId,
+            roofSegmentId: null,
+            ceilingId: null,
+            surfaceItemId: null,
+            shelfId: null,
+        };
+    }
+    if (attachTo === 'ceiling') {
+        return {
+            surface: 'ceiling',
+            wallId: null,
+            roofSegmentId: null,
+            ceilingId: node.parentId,
+            surfaceItemId: null,
+            shelfId: null,
+        };
+    }
+    // A floor item resting on a host surface (table / counter / shelf) starts in
+    // that surface, not 'floor', so the first pointer move runs the surface move
+    // handler — which preserves the grab offset — instead of a fresh `enter()`
+    // that snaps the item's origin under the cursor. Without this the item
+    // teleports the instant it's grabbed.
+    const parent = node.parentId ? useScene.getState().nodes[node.parentId] : undefined;
+    if (parent?.type === 'item') {
+        return {
+            surface: 'item-surface',
+            wallId: null,
+            roofSegmentId: null,
+            ceilingId: null,
+            surfaceItemId: node.parentId,
+            shelfId: null,
+        };
+    }
+    if (parent?.type === 'shelf') {
+        return {
+            surface: 'shelf-surface',
+            wallId: null,
+            roofSegmentId: null,
+            ceilingId: null,
+            surfaceItemId: null,
+            shelfId: node.parentId,
+        };
+    }
+    return {
+        surface: 'floor',
+        wallId: null,
+        roofSegmentId: null,
+        ceilingId: null,
+        surfaceItemId: null,
+        shelfId: null,
+    };
+}
+export function MoveItemTool({ node }) {
+    const draftNode = useDraftNode();
+    const meta = typeof node.metadata === 'object' && node.metadata !== null
+        ? node.metadata
+        : {};
+    const isNew = !!meta.isNew;
+    const cursor = usePlacementCoordinator({
+        asset: node.asset,
+        draftNode,
+        // Carry painted slot overrides onto the duplicate's draft (wall/ceiling
+        // items create their draft lazily inside the coordinator).
+        slots: node.slots,
+        // Duplicates start fresh in floor mode; wall/ceiling draft is created lazily by ensureDraft.
+        initialState: isNew
+            ? {
+                surface: 'floor',
+                wallId: null,
+                roofSegmentId: null,
+                ceilingId: null,
+                surfaceItemId: null,
+                shelfId: null,
+            }
+            : getInitialState(node),
+        // Preserve the original item's scale so Y-position calculations use the correct height.
+        defaultScale: isNew ? node.scale : undefined,
+        preserveDragOffset: true,
+        initDraft: (gridPosition) => {
+            if (isNew) {
+                // Duplicate: floor items get a draft immediately; wall/ceiling
+                // items are created lazily on surface entry.
+                gridPosition.copy(new Vector3(...node.position));
+                if (!node.asset.attachTo) {
+                    draftNode.create(gridPosition, node.asset, node.rotation, node.scale, node.slots);
+                }
+            }
+            else {
+                draftNode.adopt(node);
+                gridPosition.copy(new Vector3(...node.position));
+            }
+        },
+        onCommitted: () => {
+            triggerSFX('sfx:item-place');
+            useEditor.getState().setMovingNode(null);
+            return false;
+        },
+        onCancel: () => {
+            draftNode.destroy();
+            useEditor.getState().setMovingNode(null);
+        },
+    });
+    return _jsx(_Fragment, { children: cursor });
+}
+export default MoveItemTool;

package/dist/item/paint.d.ts

@@ -0,0 +1,3 @@
+import { type PaintCapability } from '@pascal-app/core';
+export declare const itemPaint: PaintCapability;
+//# sourceMappingURL=paint.d.ts.map

package/dist/item/paint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/item/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,eAAe,EAMrB,MAAM,kBAAkB,CAAA;AA+NzB,eAAO,MAAM,SAAS,EAAE,eAoBvB,CAAA"}