@pascal-app/core 1.0.3 → 1.0.5

package/dist/agent-operations/furniture-kind.d.ts

@@ -0,0 +1,22 @@
+import { type ItemNode } from '../schema/index.js';
+/** How a piece of furniture stands in a room, read from what the catalog calls it. */
+export type FurnitureKind = 'chair' | 'free' | 'wall';
+type Named = {
+    id: string;
+    name?: string | undefined;
+};
+/** Only a named, flat floor covering is nonblocking, never an arbitrary short solid or low top surface. */
+export declare function isFloorUnderlay(item: ItemNode): boolean;
+/**
+ * Wall-bound pieces (a fridge, a counter, a bed, a sofa) stand against a wall and never in the
+ * middle of a room; free-standing ones (a dining table, a rug, a plant) may take the middle; a chair
+ * is placed around its table. A name the table does not know is free-standing.
+ */
+export declare function furnitureKind(asset: Named): FurnitureKind;
+/**
+ * What a piece faces when it does not stand against a wall, as a pattern for the name of the item
+ * it belongs with: the coffee table and the TV face the sofa, a chair faces its table.
+ */
+export declare function anchorOf(asset: Named): string | null;
+export {};
+//# sourceMappingURL=furniture-kind.d.ts.map

package/dist/agent-operations/furniture-kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"furniture-kind.d.ts","sourceRoot":"","sources":["../../src/agent-operations/furniture-kind.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,QAAQ,EAAuC,MAAM,WAAW,CAAA;AAEnG,sFAAsF;AACtF,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAA;AAErD,KAAK,KAAK,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAA;AAetD,2GAA2G;AAC3G,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CA+BvD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,aAAa,CAQzD;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,CAMpD"}

package/dist/agent-operations/furniture-kind.js

@@ -0,0 +1,69 @@
+import { getScaledDimensions, LOW_PROFILE_ITEM_SURFACE_MAX_HEIGHT } from '../schema/index.js';
+const read = (asset) => `${asset.id} ${asset.name ?? ''}`.toLowerCase().replace(/[_]+/g, ' ');
+/** An armchair is a free-standing seat of the living group, not a chair of a table. */
+const ARMCHAIR = /arm ?chair|living ?room|lounge|rocking|recliner/;
+const CHAIR = /(?:^|[^a-z])(?:chair|stool)(?![a-z])/;
+/** A bedside table stands against the wall like the bed it serves, whatever the word "table" says. */
+const BEDSIDE = /bedside|night ?stand/;
+/** A bar, island or peninsula is walked around, and utensils sit on other pieces: none stands against a wall. */
+const WALKED_AROUND = /(?:^|[^a-z])(?:island|peninsula|bar)(?![a-z])|utensil/;
+const FREE = /table|rug|carpet|plant|lamp|ottoman|pouf/;
+const WALL = /fridge|refrigerator|counter|kitchen|stove|oven|cooktop|sink|tv[ -]?(?:stand|unit)|television|dresser|wardrobe|closet|sofa|couch|loveseat|(?:^|[^a-z])bed(?![a-z])|toilet|bath|shower|bookcase|bookshelf|cabinet|washing|washer|dryer|coat/;
+/** Only a named, flat floor covering is nonblocking, never an arbitrary short solid or low top surface. */
+export function isFloorUnderlay(item) {
+    const text = read(item.asset);
+    if (!/(?:^|[^a-z])(?:rug|carpet|(?:floor|parking)[ -]?mat)(?![a-z])/.test(text) ||
+        WALL.test(text) ||
+        CHAIR.test(text) ||
+        /table|desk|ottoman|pouf/.test(text) ||
+        item.asset.attachTo)
+        return false;
+    const dims = getScaledDimensions(item);
+    if (![...item.position, ...item.rotation, ...item.scale, ...dims].every(Number.isFinite) ||
+        !item.scale.every((value) => value > 0) ||
+        dims[0] <= 0 ||
+        dims[2] <= 0 ||
+        Math.abs(item.position[1]) > 1e-6 ||
+        Math.abs(item.rotation[0]) > 1e-6 ||
+        Math.abs(item.rotation[2]) > 1e-6)
+        return false;
+    const bounds = item.source?.manifest.bounds;
+    const bottom = bounds ? bounds.min[1] * item.scale[1] : 0;
+    const top = bounds ? bounds.max[1] * item.scale[1] : dims[1];
+    return (Number.isFinite(bottom) &&
+        Number.isFinite(top) &&
+        bottom >= -1e-6 &&
+        top >= bottom &&
+        top <= LOW_PROFILE_ITEM_SURFACE_MAX_HEIGHT);
+}
+/**
+ * Wall-bound pieces (a fridge, a counter, a bed, a sofa) stand against a wall and never in the
+ * middle of a room; free-standing ones (a dining table, a rug, a plant) may take the middle; a chair
+ * is placed around its table. A name the table does not know is free-standing.
+ */
+export function furnitureKind(asset) {
+    const text = read(asset);
+    if (ARMCHAIR.test(text))
+        return 'free';
+    if (CHAIR.test(text))
+        return 'chair';
+    if (BEDSIDE.test(text))
+        return 'wall';
+    if (WALKED_AROUND.test(text))
+        return 'free';
+    if (FREE.test(text))
+        return 'free';
+    return WALL.test(text) ? 'wall' : 'free';
+}
+/**
+ * What a piece faces when it does not stand against a wall, as a pattern for the name of the item
+ * it belongs with: the coffee table and the TV face the sofa, a chair faces its table.
+ */
+export function anchorOf(asset) {
+    const text = read(asset);
+    if (ARMCHAIR.test(text) || /coffee[ -]?table|tv[ -]?(?:stand|unit)/.test(text))
+        return 'sofa|couch';
+    if (CHAIR.test(text))
+        return 'table|desk';
+    return null;
+}

package/dist/agent-operations/get-node.d.ts

@@ -0,0 +1,12 @@
+import type { AgentOperation } from './types.js';
+/**
+ * `get_node`: a node, whole, with what the scene decides for it (a wall's or a ceiling's height
+ * when it has none of its own, a wall's thickness, a door's or window's floor and what it hangs
+ * from, the name a level or a floor plate is shown by) and its ancestors; with the scene's
+ * materials lent, the ones its finishes use. Its children are as stored; the ids among them that
+ * name no node are listed again in `missingChildIds`.
+ */
+export declare const getNode: AgentOperation<{
+    id: string;
+}>;
+//# sourceMappingURL=get-node.d.ts.map

package/dist/agent-operations/get-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-node.d.ts","sourceRoot":"","sources":["../../src/agent-operations/get-node.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,SAAS,CAAA;AAkEzD;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,EAAE,cAAc,CAAC;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAwBlD,CAAA"}

package/dist/agent-operations/get-node.js

@@ -0,0 +1,105 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { floorFootprintName } from '../lib/floor-footprint-name.js';
+import { isFloorAnchoredOpening } from '../lib/floor-opening-footprints.js';
+import { getLevelDisplayName } from '../lib/level-name.js';
+import { getOpeningFloorDatum } from '../lib/opening-floor-datum.js';
+import { nodeSchemaForKind } from '../schema/compiled-node-parsers.js';
+import { resolveCeilingHeight } from '../services/level-height.js';
+import { getWallThickness } from '../systems/wall/wall-footprint.js';
+import { wallResolvedHeight } from './level-reads.js';
+import { referencedSceneMaterialIds } from './scene-materials.js';
+/**
+ * A node's ancestors, its parent first, up to the root. Both stores link every node's `parentId`
+ * from its parent's `children` when they load a scene, so the operation reads `parentId`.
+ */
+function ancestorIdsOf(nodes, id) {
+    const out = [];
+    const seen = new Set([id]);
+    let parentId = nodes[id]?.parentId;
+    while (parentId && nodes[parentId] && !seen.has(parentId)) {
+        seen.add(parentId);
+        out.push(parentId);
+        parentId = nodes[parentId].parentId;
+    }
+    return out;
+}
+/** What the scene decides for a node that the node does not store, from the node as parsed. */
+function resolvedFields(nodes, node) {
+    const host = node.parentId ? nodes[node.parentId] : undefined;
+    const wall = host?.type === 'wall' ? nodeSchemaForKind('wall').safeParse(host) : undefined;
+    if ((node.type === 'door' || node.type === 'window') && wall?.success)
+        return {
+            resolvedOpening: {
+                floorDatum: getOpeningFloorDatum(wall.data, node, nodes),
+                anchor: isFloorAnchoredOpening(node) ? 'floor' : 'wall',
+            },
+        };
+    if (node.type === 'wall')
+        return {
+            resolvedHeight: wallResolvedHeight(nodes, node),
+            heightIsExplicit: node.height !== undefined,
+            resolvedThickness: getWallThickness(node),
+        };
+    if (node.type === 'ceiling')
+        return {
+            resolvedHeight: resolveCeilingHeight(node, nodes),
+            heightIsExplicit: node.height != null,
+        };
+    if (node.type === 'level')
+        return { displayName: getLevelDisplayName(node) };
+    if (node.type === 'slab' && node.plateRole === 'base')
+        return { displayName: floorFootprintName(nodes, node) };
+    return {};
+}
+/**
+ * The resolved fields of a core node, read from it as its schema parses it (with the defaults a
+ * stored node may omit). A read never fails on what is around the node: a node its schema rejects,
+ * or one whose neighbours do not read, comes back as stored with `unresolved` saying why.
+ */
+function derivedFields(nodes, node) {
+    const schema = nodeSchemaForKind(node.type);
+    if (!schema)
+        return {};
+    const parsed = schema.safeParse(node);
+    if (!parsed.success)
+        return { unresolved: 'its schema rejects it: verify_scene lists what is wrong' };
+    try {
+        return resolvedFields(nodes, parsed.data);
+    }
+    catch (error) {
+        return {
+            unresolved: `the scene around it does not read (${error instanceof Error ? error.message : String(error)}): verify_scene lists what is wrong`,
+        };
+    }
+}
+/**
+ * `get_node`: a node, whole, with what the scene decides for it (a wall's or a ceiling's height
+ * when it has none of its own, a wall's thickness, a door's or window's floor and what it hangs
+ * from, the name a level or a floor plate is shown by) and its ancestors; with the scene's
+ * materials lent, the ones its finishes use. Its children are as stored; the ids among them that
+ * name no node are listed again in `missingChildIds`.
+ */
+export const getNode = (nodes, { id }, { materials }) => {
+    const node = nodes[id];
+    if (!node)
+        refuse('node_not_found', `Node not found: ${id}.`, { id });
+    const used = referencedSceneMaterialIds(node);
+    const children = node.children;
+    const missingChildIds = Array.isArray(children)
+        ? children.filter((child) => typeof child === 'string' && !nodes[child])
+        : [];
+    return {
+        result: {
+            node: { ...node, ...derivedFields(nodes, node) },
+            ancestorIds: ancestorIdsOf(nodes, id),
+            ...(missingChildIds.length ? { missingChildIds } : {}),
+            ...(materials
+                ? {
+                    materials: Object.fromEntries(Object.values(materials)
+                        .filter((material) => used.has(material.id))
+                        .map((material) => [material.id, material])),
+                }
+                : {}),
+        },
+    };
+};

package/dist/agent-operations/hosted-services.d.ts

@@ -0,0 +1,14 @@
+import { type HostedServiceAction } from '../agent-tools/hosted-services.js';
+export type HostedServiceRequest = {
+    action: HostedServiceAction;
+    /** Absent: the person acts in Pascal's own Studio, not through a plugin's grant. */
+    pluginId?: string;
+    projectId?: string;
+    maxCredits?: number;
+    input: Record<string, unknown>;
+    signal?: AbortSignal;
+};
+/** Identity, project access, provider credentials and billing are supplied by the host. */
+export type HostedServiceExecutor = (request: HostedServiceRequest) => Promise<unknown>;
+export declare function executeHostedServiceTool(name: string, raw: unknown, execute: HostedServiceExecutor, signal?: AbortSignal): Promise<unknown>;
+//# sourceMappingURL=hosted-services.d.ts.map

package/dist/agent-operations/hosted-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-services.d.ts","sourceRoot":"","sources":["../../src/agent-operations/hosted-services.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,mBAAmB,EAEzB,MAAM,gCAAgC,CAAA;AAGvC,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,mBAAmB,CAAA;IAC3B,oFAAoF;IACpF,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB,CAAA;AAED,2FAA2F;AAC3F,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAEvF,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,OAAO,EACZ,OAAO,EAAE,qBAAqB,EAC9B,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,OAAO,CAAC,CA0BlB"}

package/dist/agent-operations/hosted-services.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { findHostedServiceTool, siteContextInputSchema, } from '../agent-tools/hosted-services.js';
+import { AgentRefusal } from '../agent-tools/refusal.js';
+export async function executeHostedServiceTool(name, raw, execute, signal) {
+    const contract = findHostedServiceTool(name);
+    if (!contract)
+        throw new AgentRefusal('unknown_service_tool', 'This hosted service tool is not available.');
+    const parsed = z.object(contract.input).strict().safeParse(raw);
+    if (!parsed.success)
+        throw new AgentRefusal('invalid_service_input', 'Invalid hosted service input.', {
+            issues: parsed.error.issues.map(({ path, message }) => ({ path, message })),
+        });
+    const { pluginId, projectId, maxCredits, ...input } = parsed.data;
+    if (contract.action === 'site.pull') {
+        const { pullKey: _key, ...location } = input;
+        const valid = siteContextInputSchema.safeParse(location);
+        if (!valid.success)
+            throw new AgentRefusal('invalid_site_location', 'Supply an address or both latitude and longitude.');
+    }
+    signal?.throwIfAborted();
+    return execute({ action: contract.action, pluginId, projectId, maxCredits, input, signal });
+}