@pascal-app/core 1.0.6 → 1.0.7

package/dist/runtime/scene-runtime.js

@@ -0,0 +1,302 @@
+import { applySceneChanges } from '../agent-operations/apply-changes.js';
+import { applyAgentOutcome } from '../agent-operations/apply-outcome.js';
+import { writeCollections } from '../agent-operations/collections.js';
+import { supportIndexOf, withSpatialGrid, } from '../hooks/spatial-grid/spatial-grid-manager.js';
+import { resolveLevelId } from '../lib/node-ancestry.js';
+import { getNodePluginId, nodeRegistry } from '../registry/registry.js';
+import { withIdAllocator } from '../schema/base.js';
+import { shouldRefreshDefaultGutters, shouldRefreshDefaultRidgeVents, } from '../store/actions/node-actions.js';
+import { runSettlingDocument } from '../store/document-settling.js';
+import { pauseSceneHistory, resumeSceneHistory } from '../store/history-control.js';
+import { withoutLivePreviews } from '../store/live-previews.js';
+import { createSceneEnvironment } from '../store/scene-environment.js';
+import useScene, { createSceneStore, runAsSettledSceneStep, sceneDocumentOf, } from '../store/use-scene.js';
+import { reconcileDocument } from '../systems/document-reconcile.js';
+import { levelOf } from './dependencies.js';
+import { diffSceneDocuments, sameValue } from './patch.js';
+import { createDocumentReader, DependencyRecorder, materialize, untracked, } from './reader.js';
+/** Each registered node kind and the schema version it parses with (`plugin@version`). */
+export function captureRegistryVersions() {
+    const versions = {};
+    for (const [kind, definition] of [...nodeRegistry.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0))
+        versions[kind] = `${getNodePluginId(kind) ?? 'core'}@${definition.schemaVersion}`;
+    return versions;
+}
+export class RegistryVersionMismatchError extends Error {
+    kinds;
+    constructor(kinds) {
+        super(`The node registry differs from the one the computation was captured with: ${kinds.join(', ')}.`);
+        this.kinds = kinds;
+        this.name = 'RegistryVersionMismatchError';
+    }
+}
+function sourceOf(store, environment) {
+    return {
+        nodes: () => store.getState().nodes,
+        collections: () => store.getState().collections,
+        materials: () => store.getState().materials,
+        rootNodeIds: () => store.getState().rootNodeIds,
+        installedPlugins: () => store.getState().installedPlugins,
+        assertActive: () => environment?.assertActive(),
+    };
+}
+/** The editor's own store: plain reads, random ids, the editor's environment. */
+export const liveSceneRuntime = {
+    store: useScene,
+    reader: () => createDocumentReader(sourceOf(useScene, null), null),
+    run: (run) => run(),
+    reconcile: (before, options) => reconcileDocument(useScene, before, options),
+};
+/**
+ * Loads an already-migrated document into `store` as it is: no migration, healing or
+ * normalisation runs again (a load through `setScene` would, and could change it — closing level
+ * gaps, re-cutting openings). The store's history starts empty at this document.
+ */
+export function loadCanonicalSnapshot(store, snapshot) {
+    pauseSceneHistory(store);
+    try {
+        store.setState({
+            nodes: snapshot.nodes,
+            rootNodeIds: snapshot.rootNodeIds,
+            collections: snapshot.collections,
+            materials: snapshot.materials,
+            installedPlugins: [...snapshot.installedPlugins],
+            hasExplicitPluginInstallState: snapshot.hasExplicitPluginInstallState ?? false,
+            hydrationToken: null,
+            hydrationId: null,
+            readOnly: false,
+        });
+    }
+    finally {
+        resumeSceneHistory(store);
+    }
+    store.temporal.getState().clear();
+}
+/** Freezes plain data in place, deeply; returns it. */
+export function deepFreeze(value) {
+    if (!value || typeof value !== 'object' || Object.isFrozen(value))
+        return value;
+    Object.freeze(value);
+    for (const key of Object.keys(value))
+        deepFreeze(value[key]);
+    return value;
+}
+/** Unwraps tracked views an operation put in its changes, so the store holds plain records. */
+function plainChanges(changes) {
+    // The store takes its own copy: a detached scene freezes what it holds, and must not freeze the
+    // caller's objects (or share them with anyone else).
+    const own = (value) => structuredClone(materialize(untracked(value)));
+    const plainData = (data) => Object.fromEntries(Object.entries(untracked(data)).map(([key, value]) => [key, own(value)]));
+    return {
+        ...(changes.create && {
+            create: changes.create.map(({ node, parentId }) => ({
+                node: own(node),
+                ...(parentId === undefined ? {} : { parentId }),
+            })),
+        }),
+        ...(changes.update && {
+            update: changes.update.map(({ id, data }) => ({ id, data: plainData(data) })),
+        }),
+        ...(changes.delete && { delete: [...changes.delete] }),
+        ...(changes.collections && {
+            collections: Object.fromEntries(Object.entries(changes.collections).map(([id, collection]) => [id, own(collection)])),
+        }),
+    };
+}
+/** Applies agent changes to a store as the editor's actions do. */
+export function applySceneChangesToStore(store, changes) {
+    const { create, update, delete: remove, collections } = plainChanges(changes);
+    if (create?.length || update?.length || remove?.length)
+        store.getState().applyNodeChanges({
+            create: create,
+            update: update,
+            delete: remove,
+        });
+    if (collections && Object.keys(collections).length)
+        store.setState({
+            collections: writeCollections(store.getState().collections, collections),
+        });
+}
+/**
+ * What a runtime lends an agent operation's outcome (`applyAgentOutcome`): its changes applied as
+ * the editor's actions apply them, each followed by the document reconciliation, and an explicit
+ * reconcile of every level. One undo step per call.
+ */
+export function createAgentHost(runtime) {
+    const nodes = () => runtime.store.getState().nodes;
+    return {
+        getNodes: () => runtime.reader().nodes,
+        applyChanges: (changes) => runtime.run(() => runSettlingDocument(runtime.store, () => runAsSettledSceneStep(runtime.store, () => {
+            const before = nodes();
+            applySceneChangesToStore(runtime.store, changes);
+            declareActionDependencies(runtime, before, changes);
+            runtime.reconcile(before);
+        }))),
+        reconcile: () => runtime.run(() => runSettlingDocument(runtime.store, () => runAsSettledSceneStep(runtime.store, () => runtime.reconcile(nodes(), { allLevels: true })))),
+    };
+}
+/** Kinds whose writes the store's actions plan around (gutters, ridge vents, downspouts). */
+const PLANNED_KINDS = new Set([
+    'roof',
+    'roof-segment',
+    'lean-to-extension',
+    'gutter',
+    'downspout',
+    'ridge-vent',
+]);
+/**
+ * The store's actions plan more than they are asked for, reading the scene directly: default
+ * gutters, ridge vents and downspouts around roof edits, merged walls and cleaned references
+ * around deletions, walls kept clear of each other on a curve, sanitised values. Whatever such a
+ * planner read is a dependency, whether or not it wrote anything (a disabled gutter is a decision
+ * too), so each level its triggers touch becomes a `scope` dependency (the whole document for a
+ * node outside every level); so does each level an unrequested write lands on.
+ */
+export function declareActionDependencies(runtime, before, changes) {
+    const declare = runtime.declare?.bind(runtime);
+    if (!declare)
+        return;
+    const plain = plainChanges(changes);
+    const intended = applySceneChanges(before, plain);
+    const after = runtime.store.getState().nodes;
+    const kindOf = (id) => (after[id] ?? before[id] ?? intended[id])?.type;
+    const touched = new Set();
+    for (const id of plain.delete ?? [])
+        touched.add(id);
+    for (const { node } of plain.create ?? [])
+        if (PLANNED_KINDS.has(node.type))
+            touched.add(node.id);
+    for (const { id, data } of plain.update ?? []) {
+        const kind = kindOf(id);
+        // A segment's planners run on the fields they read (a rename runs none).
+        const planned = kind === 'roof-segment'
+            ? shouldRefreshDefaultGutters(data) || shouldRefreshDefaultRidgeVents(data)
+            : PLANNED_KINDS.has(kind ?? '') || (kind === 'wall' && 'curveOffset' in data);
+        if (planned)
+            touched.add(id);
+    }
+    let extra = false;
+    for (const id of new Set([...Object.keys(intended), ...Object.keys(after)]))
+        if (intended[id] !== after[id] && !sameValue(intended[id], after[id])) {
+            extra = true;
+            touched.add(id);
+        }
+    if (extra) {
+        for (const { node } of plain.create ?? [])
+            touched.add(node.id);
+        for (const { id } of plain.update ?? [])
+            touched.add(id);
+    }
+    const levels = new Set();
+    for (const id of touched)
+        for (const nodes of [before, after, intended])
+            if (nodes[id])
+                levels.add(levelOf(nodes, id));
+    for (const level of levels)
+        declare(level ? { kind: 'scope', level } : { kind: 'scope', whole: true });
+}
+/**
+ * A support index over the scene's own nodes that records, for every query about a level, a
+ * `scope` dependency on that level: support reads walk spatial indexes the reader cannot see. A
+ * query names its level first, or a node on it (`canPlaceOnCeiling` its ceiling): the scope is the
+ * level that node is on, the whole document for one on none.
+ */
+function recordingSupportGrid(store, recorder) {
+    const recordings = new WeakMap();
+    return () => {
+        const grid = supportIndexOf(store, resolveLevelId);
+        let recording = recordings.get(grid);
+        if (!recording) {
+            recording = new Proxy(grid, {
+                get(target, key, receiver) {
+                    const value = Reflect.get(target, key, receiver);
+                    if (typeof value !== 'function')
+                        return value;
+                    return (...args) => {
+                        const [subject] = args;
+                        const nodes = store.getState().nodes;
+                        if (typeof subject === 'string' && nodes[subject]) {
+                            const level = levelOf(nodes, subject);
+                            recorder.declare(level ? { kind: 'scope', level } : { kind: 'scope', whole: true });
+                        }
+                        return value.apply(target, args);
+                    };
+                },
+            });
+            recordings.set(grid, recording);
+        }
+        return recording;
+    };
+}
+/**
+ * Opens a detached scene over a canonical snapshot (already migrated: `getSceneDocument()` of a
+ * loaded editor, or a saved draft). It has its own store, history, commit bus, drafts and support
+ * index, so nothing done on it reaches the editor. Every id it mints comes from `ids` (use
+ * `effectIds(effectId)` to make a recomputation mint the same ones), and every read made through
+ * its reader, host and reconciliation is recorded.
+ */
+export function openDetachedScene(snapshot, options) {
+    const current = captureRegistryVersions();
+    const mismatched = [
+        ...new Set([...Object.keys(current), ...Object.keys(options.context.registryVersions)]),
+    ].filter((kind) => current[kind] !== options.context.registryVersions[kind]);
+    if (mismatched.length)
+        throw new RegistryVersionMismatchError(mismatched);
+    const environment = createSceneEnvironment(`detached at ${JSON.stringify(options.base)}`);
+    const store = createSceneStore(environment);
+    // The scene owns its data, read-only throughout: nothing reached through it (a nested array of
+    // a node, a material) can change the caller's snapshot, the editor's store, or the baseline its
+    // patch is taken against without going through its own writes.
+    loadCanonicalSnapshot(store, deepFreeze(structuredClone(snapshot)));
+    store.subscribe((state, previous) => {
+        for (const key of ['nodes', 'collections', 'materials']) {
+            const next = state[key];
+            const before = previous[key];
+            if (next === before)
+                continue;
+            for (const id in next)
+                if (next[id] !== before[id])
+                    deepFreeze(next[id]);
+            Object.freeze(next);
+        }
+    });
+    const base = sceneDocumentOf(store);
+    const recorder = new DependencyRecorder();
+    const reader = createDocumentReader(sourceOf(store, environment), recorder);
+    const grid = recordingSupportGrid(store, recorder);
+    const run = (work) => environment.run(() => withIdAllocator(options.ids, () => withoutLivePreviews(() => withSpatialGrid(grid, work))));
+    const rawNodes = () => store.getState().nodes;
+    const reconcile = (before, reconcileOptions = {}) => {
+        run(() => reconcileDocument(store, before, { ...reconcileOptions, read: reader.track, grid }));
+        settled = rawNodes();
+    };
+    let settled = rawNodes();
+    const scene = {
+        base: options.base,
+        context: options.context,
+        store,
+        reader: () => reader,
+        run,
+        reconcile,
+        host: () => createAgentHost(scene),
+        execute: (operation, input, context) => run(() => materialize(applyAgentOutcome(operation(reader.nodes, input, context), createAgentHost(scene)))),
+        declare: (dependency) => {
+            environment.assertActive();
+            recorder.declare(dependency);
+        },
+        dependencies: () => {
+            environment.assertActive();
+            return recorder.dependencies();
+        },
+        patch: () => {
+            if (rawNodes() !== settled)
+                reconcile(settled);
+            return diffSceneDocuments(base, sceneDocumentOf(store));
+        },
+        dispose: () => environment.dispose(),
+        get disposed() {
+            return environment.disposed;
+        },
+    };
+    return scene;
+}

package/dist/schema/__fixtures__/node-fixtures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-fixtures.d.ts","sourceRoot":"","sources":["../../../src/schema/__fixtures__/node-fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,EAAW,KAAK,WAAW,EAAc,MAAM,UAAU,CAAA;AAEhE;;;;;GAKG;AAEH,0EAA0E;AAC1E,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAuExE,CAAA;AAED,6CAA6C;AAC7C,eAAO,MAAM,UAAU,EAAE,WAAW,EAAoC,CAAA;AAExE,+EAA+E;AAC/E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,SAAS,CAC1C;IAAE,IAAI,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAA;CAAE,GAAG,CAAC,CAAC,IAAI,CAAC,cAAc,CACrE,CAAA;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAIhF;AAID,iFAAiF;AACjF,wBAAgB,mBAAmB,IAAI,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CASrE;AAID;;;;;;GAMG;AACH,wBAAgB,YAAY,IAAI,GAAG,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAkBxE"}
+{"version":3,"file":"node-fixtures.d.ts","sourceRoot":"","sources":["../../../src/schema/__fixtures__/node-fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,EAAW,KAAK,WAAW,EAAc,MAAM,UAAU,CAAA;AAEhE;;;;;GAKG;AAEH,0EAA0E;AAC1E,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAwExE,CAAA;AAED,6CAA6C;AAC7C,eAAO,MAAM,UAAU,EAAE,WAAW,EAAoC,CAAA;AAExE,+EAA+E;AAC/E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,SAAS,CAC1C;IAAE,IAAI,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAA;CAAE,GAAG,CAAC,CAAC,IAAI,CAAC,cAAc,CACrE,CAAA;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAIhF;AAID,iFAAiF;AACjF,wBAAgB,mBAAmB,IAAI,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CASrE;AAID;;;;;;GAMG;AACH,wBAAgB,YAAY,IAAI,GAAG,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAkBxE"}

package/dist/schema/__fixtures__/node-fixtures.js

@@ -10,6 +10,7 @@ import { AnyNode, nodeKindOf } from '../types.js';
  */
 /** Fields a kind requires beyond the defaults its own schema fills in. */
 export const NODE_REQUIRED_FIELDS = {
+    beam: { start: [0, 0], end: [4, 0] },
     ceiling: {
         polygon: [
             [0, 0],

package/dist/schema/assembly.d.ts

@@ -60,6 +60,7 @@ export declare const AssemblyLayer: z.ZodObject<{
     }>;
     thickness: z.ZodNumber;
     core: z.ZodOptional<z.ZodLiteral<true>>;
+    spacing: z.ZodOptional<z.ZodNumber>;
     material: z.ZodOptional<z.ZodString>;
     slot: z.ZodOptional<z.ZodString>;
     returns: z.ZodOptional<z.ZodBoolean>;
@@ -95,6 +96,7 @@ export declare const Assembly: z.ZodObject<{
         }>;
         thickness: z.ZodNumber;
         core: z.ZodOptional<z.ZodLiteral<true>>;
+        spacing: z.ZodOptional<z.ZodNumber>;
         material: z.ZodOptional<z.ZodString>;
         slot: z.ZodOptional<z.ZodString>;
         returns: z.ZodOptional<z.ZodBoolean>;
@@ -128,6 +130,7 @@ export declare const Assembly: z.ZodObject<{
         }>;
         thickness: z.ZodNumber;
         core: z.ZodOptional<z.ZodLiteral<true>>;
+        spacing: z.ZodOptional<z.ZodNumber>;
         material: z.ZodOptional<z.ZodString>;
         slot: z.ZodOptional<z.ZodString>;
         returns: z.ZodOptional<z.ZodBoolean>;

package/dist/schema/assembly.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assembly.d.ts","sourceRoot":"","sources":["../../src/schema/assembly.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;EAgBpB,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAEjD;;;;GAIG;AACH,eAAO,MAAM,eAAe,aAA6C,CAAA;AAEzE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAMzD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+EjB,CAAA;AACJ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,sCAAsC;AACtC,eAAO,MAAM,kBAAkB,WAAO,CAAA"}
+{"version":3,"file":"assembly.d.ts","sourceRoot":"","sources":["../../src/schema/assembly.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;EAgBpB,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAEjD;;;;GAIG;AACH,eAAO,MAAM,eAAe,aAA6C,CAAA;AAEzE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+BxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAMzD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0FjB,CAAA;AACJ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,sCAAsC;AACtC,eAAO,MAAM,kBAAkB,WAAO,CAAA"}

package/dist/schema/assembly.js

@@ -46,6 +46,8 @@ export const AssemblyLayer = z.object({
     thickness: z.number().finite().nonnegative(),
     /** Body only, at most one: the structural layer (framing, block), the one generators frame. */
     core: z.literal(true).optional(),
+    /** The core layer's framing members on centre, metres (studs at 16 in); absent = the framer's own. */
+    spacing: z.number().finite().positive().optional(),
     /**
      * What the layer is built of, as a construction-material kind
      * (`stucco`, `siding`, `osb`, `wood`, `cmu`, `drywall`, …). A label for
@@ -113,6 +115,17 @@ export const Assembly = z
             seen.add(layer.id);
         });
     }
+    for (const [list, layers] of lists) {
+        layers.forEach((layer, index) => {
+            if (layer.spacing !== undefined && !layer.core) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: 'Only the core layer has a framing spacing',
+                    path: [list, index, 'spacing'],
+                });
+            }
+        });
+    }
     assembly.layers.forEach((layer, index) => {
         if (layer.core && !STRUCTURAL_ROLES.has(layer.role)) {
             ctx.addIssue({

package/dist/schema/asset-url.d.ts

@@ -12,10 +12,45 @@ import { z } from 'zod';
 declare const ALLOWED_SCHEMES: readonly ['artifact:', 'asset:', 'blob:', 'https:', 'data:image/'];
 /**
  * Optional environment variable that narrows which `https:` origins are
- * accepted. Set to a comma-separated list (e.g. `https://cdn.pascal.app`).
- * When unset, any `https:` origin is permitted.
+ * accepted, here and by the MCP server's `safeFetch`. Set to a comma-separated
+ * list (e.g. `https://cdn.pascal.app`). When unset or empty, any `https:`
+ * origin is permitted; when set, only listed origins are, and a value with no
+ * valid entry (whitespace only, every entry malformed) permits no `https:` origin.
  */
 export declare const ALLOWED_ORIGINS_ENV = "PASCAL_ALLOWED_ASSET_ORIGINS";
+export type AllowedOriginIssue = {
+    /** Position of the entry in the comma-separated list, from 0. */
+    index: number;
+    /**
+     * `credentials_dropped`: the entry is kept for its origin, its userinfo is not.
+     * Every other reason means the entry was skipped.
+     */
+    reason: 'not_a_url' | 'scheme_not_allowed' | 'wildcard_not_supported' | 'credentials_dropped';
+};
+/**
+ * Parses an origin allowlist into normalised origins (`new URL(entry).origin`),
+ * so `https://CDN.example.com:443/` and `https://cdn.example.com` are the same
+ * entry. Only `http:` and `https:` entries count: other schemes either have no
+ * origin or, like `blob:https://…`, borrow one they were not meant to grant.
+ * Wildcard hosts (`https://*.example.com`) are not patterns, so they are
+ * rejected rather than kept as an origin that never matches. Issues are
+ * reported by position and reason only, never by value, since an entry may
+ * carry credentials (`https://user:secret@host`).
+ */
+export declare function parseAllowedOrigins(raw: string): {
+    origins: Set<string>;
+    issues: AllowedOriginIssue[];
+};
+/** Test-only: forget the cached allowlist so its warnings are logged again. */
+export declare function __resetAllowedOriginsCacheForTests(): void;
+/**
+ * The allowlist set in `raw` (the value of {@link ALLOWED_ORIGINS_ENV}), or
+ * `undefined` when it is unset or empty. Only the most recent value is cached,
+ * so its warnings (skipped entries, dropped credentials, no valid entry, no
+ * https: entry) are logged when a value is first read and again whenever the
+ * value changes.
+ */
+export declare function allowedOriginsFrom(raw: string | undefined): ReadonlySet<string> | undefined;
 /**
  * Zod validator for asset-style URL fields. Accepts:
  * - `asset://…` internal handles

package/dist/schema/asset-url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"asset-url.d.ts","sourceRoot":"","sources":["../../src/schema/asset-url.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;;;GASG;AACH,QAAA,MAAM,eAAe,YAAI,WAAW,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa,CAAU,CAAA;AAE1F;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,iCAAiC,CAAA;AAwCjE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,aAGnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAG/C,OAAO,EAAE,eAAe,EAAE,CAAA"}
+{"version":3,"file":"asset-url.d.ts","sourceRoot":"","sources":["../../src/schema/asset-url.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;;;GASG;AACH,QAAA,MAAM,eAAe,YAAI,WAAW,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa,CAAU,CAAA;AAE1F;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,iCAAiC,CAAA;AAEjE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAA;IACb;;;OAGG;IACH,MAAM,EAAE,WAAW,GAAG,oBAAoB,GAAG,wBAAwB,GAAG,qBAAqB,CAAA;CAC9F,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG;IAChD,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACpB,MAAM,EAAE,kBAAkB,EAAE,CAAA;CAC7B,CAyBA;AAID,+EAA+E;AAC/E,wBAAgB,kCAAkC,IAAI,IAAI,CAEzD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,CAsB3F;AAkCD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,aAGnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAG/C,OAAO,EAAE,eAAe,EAAE,CAAA"}

package/dist/schema/asset-url.js

@@ -12,22 +12,91 @@ import { z } from 'zod';
 const ALLOWED_SCHEMES = ['artifact:', 'asset:', 'blob:', 'https:', 'data:image/'];
 /**
  * Optional environment variable that narrows which `https:` origins are
- * accepted. Set to a comma-separated list (e.g. `https://cdn.pascal.app`).
- * When unset, any `https:` origin is permitted.
+ * accepted, here and by the MCP server's `safeFetch`. Set to a comma-separated
+ * list (e.g. `https://cdn.pascal.app`). When unset or empty, any `https:`
+ * origin is permitted; when set, only listed origins are, and a value with no
+ * valid entry (whitespace only, every entry malformed) permits no `https:` origin.
  */
 export const ALLOWED_ORIGINS_ENV = 'PASCAL_ALLOWED_ASSET_ORIGINS';
+/**
+ * Parses an origin allowlist into normalised origins (`new URL(entry).origin`),
+ * so `https://CDN.example.com:443/` and `https://cdn.example.com` are the same
+ * entry. Only `http:` and `https:` entries count: other schemes either have no
+ * origin or, like `blob:https://…`, borrow one they were not meant to grant.
+ * Wildcard hosts (`https://*.example.com`) are not patterns, so they are
+ * rejected rather than kept as an origin that never matches. Issues are
+ * reported by position and reason only, never by value, since an entry may
+ * carry credentials (`https://user:secret@host`).
+ */
+export function parseAllowedOrigins(raw) {
+    const origins = new Set();
+    const issues = [];
+    raw.split(',').forEach((entry, index) => {
+        const trimmed = entry.trim();
+        if (!trimmed)
+            return;
+        let parsed;
+        try {
+            parsed = new URL(trimmed);
+        }
+        catch {
+            issues.push({ index, reason: 'not_a_url' });
+            return;
+        }
+        if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+            issues.push({ index, reason: 'scheme_not_allowed' });
+            return;
+        }
+        if (parsed.hostname.includes('*')) {
+            issues.push({ index, reason: 'wildcard_not_supported' });
+            return;
+        }
+        if (parsed.username || parsed.password)
+            issues.push({ index, reason: 'credentials_dropped' });
+        origins.add(parsed.origin);
+    });
+    return { origins, issues };
+}
+let allowlistCache = null;
+/** Test-only: forget the cached allowlist so its warnings are logged again. */
+export function __resetAllowedOriginsCacheForTests() {
+    allowlistCache = null;
+}
+/**
+ * The allowlist set in `raw` (the value of {@link ALLOWED_ORIGINS_ENV}), or
+ * `undefined` when it is unset or empty. Only the most recent value is cached,
+ * so its warnings (skipped entries, dropped credentials, no valid entry, no
+ * https: entry) are logged when a value is first read and again whenever the
+ * value changes.
+ */
+export function allowedOriginsFrom(raw) {
+    if (!raw)
+        return undefined;
+    if (allowlistCache?.raw === raw)
+        return allowlistCache.origins;
+    const { origins, issues } = parseAllowedOrigins(raw);
+    for (const issue of issues) {
+        if (issue.reason === 'credentials_dropped') {
+            console.warn(`[pascal] asset_allowlist_entry_credentials_dropped ${JSON.stringify({ index: issue.index })}`);
+        }
+        else {
+            console.warn(`[pascal] asset_allowlist_entry_ignored ${JSON.stringify(issue)}`);
+        }
+    }
+    if (origins.size === 0) {
+        console.warn('[pascal] asset_allowlist_has_no_valid_entries: no origin is permitted');
+    }
+    else if (![...origins].some((origin) => origin.startsWith('https://'))) {
+        console.warn('[pascal] asset_allowlist_has_no_https_entries: scene asset URLs accept only https: origins, so every one is rejected (safeFetch still fetches the listed http: origins)');
+    }
+    allowlistCache = { raw, origins };
+    return origins;
+}
 // Narrow access to the environment variable without requiring @types/node in
 // this package. The core package ships to both browser and Node contexts.
 function readAllowedOrigins() {
     const g = globalThis;
-    const value = g.process?.env?.[ALLOWED_ORIGINS_ENV];
-    if (!value)
-        return undefined;
-    const list = value
-        .split(',')
-        .map((s) => s.trim())
-        .filter((s) => s.length > 0);
-    return list.length > 0 ? list : undefined;
+    return allowedOriginsFrom(g.process?.env?.[ALLOWED_ORIGINS_ENV]);
 }
 function isAllowedAssetUrl(url) {
     if (typeof url !== 'string' || url.length === 0)
@@ -54,7 +123,7 @@ function isAllowedAssetUrl(url) {
         if (parsed.protocol === 'https:') {
             const allowlist = readAllowedOrigins();
             if (allowlist)
-                return allowlist.includes(parsed.origin);
+                return allowlist.has(parsed.origin);
         }
         return true;
     }

package/dist/schema/base.d.ts

@@ -4,6 +4,14 @@ import { z } from 'zod';
  * @example 'white', 'brick', 'wood', 'glass', 'preview-valid'
  */
 export declare const Material: z.ZodOptional<z.ZodString>;
+/** Mints the id of a new entity from its prefix: `wall` → `wall_…`. */
+export type IdAllocator = (prefix: string) => string;
+/**
+ * Runs `run` with `ids` minting every id it asks `generateId` (and so every schema default) for,
+ * synchronously: a detached scene allocates deterministic ids this way (`effectIds`). Outside a
+ * scope, ids are random.
+ */
+export declare function withIdAllocator<T>(ids: IdAllocator, run: () => T): T;
 export declare const generateId: <T extends string>(prefix: T) => `${T}_${string}`;
 export declare const objectId: <T extends string>(prefix: T) => z.ZodDefault<z.ZodTemplateLiteral<`${`${T}_` extends infer T_1 ? T_1 extends `${T}_` ? T_1 extends string | number | bigint | boolean | null | undefined ? `${T_1 extends infer T_2 ? T_2 extends T_1 ? T_2 extends undefined ? "" : T_2 : never : never}` : T_1 extends z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> ? `${z.infer<T_1> extends infer T_3 extends string | number | bigint | boolean | null | undefined ? T_3 extends undefined ? "" : T_3 : never}` : never : never : never}${string}`>>;
 export declare const nodeType: <T extends string>(type: T) => z.ZodDefault<z.ZodLiteral<T>>;

package/dist/schema/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/schema/base.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB;;;GAGG;AACH,eAAO,MAAM,QAAQ,4BAAwB,CAAA;AAC7C,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,MAAM,UAAU,CAAC,KAAG,GAAG,CAAC,IAAI,MAAM,EACxB,CAAA;AAC/C,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,MAAM,UAAU,CAAC,+gBAInD,CAAA;AACD,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,MAAM,QAAQ,CAAC,kCAAkC,CAAA;AAEpF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/schema/base.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB;;;GAGG;AACH,eAAO,MAAM,QAAQ,4BAAwB,CAAA;AAC7C,uEAAuE;AACvE,MAAM,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAA;AAIpD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,CAOpE;AAED,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,MAAM,UAAU,CAAC,KAAG,GAAG,CAAC,IAAI,MAAM,EAGtE,CAAA;AACD,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,MAAM,UAAU,CAAC,+gBAInD,CAAA;AACD,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,MAAM,QAAQ,CAAC,kCAAkC,CAAA;AAEpF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/base.js

@@ -8,7 +8,25 @@ const customId = customAlphabet('0123456789abcdefghijklmnopqrstuvwxyz', 16);
  * @example 'white', 'brick', 'wood', 'glass', 'preview-valid'
  */
 export const Material = z.string().optional();
-export const generateId = (prefix) => `${prefix}_${customId()}`;
+const idAllocators = [];
+/**
+ * Runs `run` with `ids` minting every id it asks `generateId` (and so every schema default) for,
+ * synchronously: a detached scene allocates deterministic ids this way (`effectIds`). Outside a
+ * scope, ids are random.
+ */
+export function withIdAllocator(ids, run) {
+    idAllocators.push(ids);
+    try {
+        return run();
+    }
+    finally {
+        idAllocators.pop();
+    }
+}
+export const generateId = (prefix) => {
+    const allocate = idAllocators.at(-1);
+    return (allocate ? allocate(prefix) : `${prefix}_${customId()}`);
+};
 export const objectId = (prefix) => {
     const schema = z.templateLiteral([`${prefix}_`, z.string()]);
     return schema.default(() => generateId(prefix));