@pascal-app/core 1.0.6 → 1.0.7

package/dist/runtime/reader.js

@@ -0,0 +1,455 @@
+import { matchesNodePredicate, queryIds, } from './dependencies.js';
+/** Accumulates a computation's reads. */
+export class DependencyRecorder {
+    nodes = new Map();
+    collections = new Map();
+    materials = new Set();
+    queries = new Map();
+    orders = new Map();
+    declared = new Map();
+    plugins = false;
+    node(id, field) {
+        const fields = this.nodes.get(id) ?? new Set();
+        this.nodes.set(id, fields);
+        if (field !== undefined)
+            fields.add(field);
+    }
+    collection(id, field) {
+        const fields = this.collections.get(id) ?? new Set();
+        this.collections.set(id, fields);
+        if (field !== undefined)
+            fields.add(field);
+    }
+    material(id) {
+        this.materials.add(id);
+    }
+    installedPlugins() {
+        this.plugins = true;
+    }
+    query(dependency) {
+        this.queries.set(JSON.stringify([dependency.entity, dependency.predicate]), dependency);
+    }
+    order(parentId, childIds) {
+        if (!this.orders.has(parentId))
+            this.orders.set(parentId, [...childIds]);
+    }
+    /** A dependency the host declares: a file or artifact it read, or a conservative scope. */
+    declare(dependency) {
+        this.declared.set(JSON.stringify(dependency), dependency);
+    }
+    dependencies() {
+        return [
+            ...[...this.nodes].map(([id, fields]) => ({
+                kind: 'node',
+                id,
+                fields: [...fields].sort(),
+            })),
+            ...this.queries.values(),
+            ...[...this.orders].map(([parentId, childIds]) => ({
+                kind: 'order',
+                parentId,
+                childIds,
+            })),
+            ...[...this.collections].map(([id, fields]) => ({
+                kind: 'collection',
+                id,
+                fields: [...fields].sort(),
+            })),
+            ...[...this.materials].map((id) => ({ kind: 'material', id })),
+            ...(this.plugins ? [{ kind: 'plugins' }] : []),
+            ...this.declared.values(),
+        ];
+    }
+}
+const rawOfView = new WeakMap();
+const queriesOfRecord = new WeakMap();
+/**
+ * The tracked selections behind a record view, when it is one (a detached scene's): helpers that
+ * receive `SceneNodes` query through them, so they record what they select rather than everything.
+ * They read the version the view is of, not the scene's current one.
+ */
+export function readerOf(record) {
+    return queriesOfRecord.get(record);
+}
+/** Drafts over a tracked view: a draft of one is a draft over it, never a copy. */
+const drafts = new WeakSet();
+/**
+ * A record to write a draft into, over `record`: a plain record is copied; a tracked view's (or a
+ * draft's) draft reads through to it entry by entry, so a draft that is only written and read by id
+ * records those ids, not a read of every entry (enumerating the draft still reads the whole view).
+ */
+export function draftOf(record) {
+    if (!(rawOfView.has(record) || drafts.has(record)))
+        return { ...record };
+    const written = new Map();
+    const removed = new Set();
+    const has = (key) => written.has(key) || (!removed.has(key) && key in record);
+    const read = (key) => written.has(key) ? written.get(key) : removed.has(key) ? undefined : record[key];
+    const draft = new Proxy({}, {
+        get: (_, key) => (typeof key === 'string' ? read(key) : undefined),
+        has: (_, key) => typeof key === 'string' && has(key),
+        set(_, key, value) {
+            if (typeof key !== 'string')
+                return false;
+            written.set(key, value);
+            removed.delete(key);
+            return true;
+        },
+        deleteProperty(_, key) {
+            if (typeof key !== 'string')
+                return false;
+            written.delete(key);
+            removed.add(key);
+            return true;
+        },
+        ownKeys: () => [
+            ...new Set([...Object.keys(record).filter((key) => !removed.has(key)), ...written.keys()]),
+        ],
+        getOwnPropertyDescriptor: (_, key) => typeof key === 'string' && has(key)
+            ? { value: read(key), writable: true, enumerable: true, configurable: true }
+            : undefined,
+    });
+    drafts.add(draft);
+    const base = readerOf(record);
+    if (base)
+        queriesOfRecord.set(draft, {
+            // What a selection over the record beneath finds, with the draft's writes over it.
+            query: ((selection) => {
+                if (selection.entity !== 'node')
+                    return base.query(selection);
+                const where = selection.where ?? null;
+                const matches = (node) => matchesNodePredicate(node, where);
+                const found = base.query({ entity: 'node', where: selection.where });
+                const idOf = (node) => node.id;
+                const listed = new Set(found.map(idOf));
+                const added = [];
+                for (const [id, node] of written) {
+                    if (listed.has(id) || !matches(node))
+                        continue;
+                    // An entry the draft changed into the selection: only the whole draft knows its place.
+                    if (id in record)
+                        return Object.values(draft).filter(matches);
+                    added.push(node);
+                }
+                const kept = found.flatMap((node) => {
+                    const id = idOf(node);
+                    if (removed.has(id))
+                        return [];
+                    if (!written.has(id))
+                        return [node];
+                    const next = written.get(id);
+                    return matches(next) ? [next] : [];
+                });
+                return [...kept, ...added];
+            }),
+            orderedChildren: (id) => written.has(id)
+                ? [...childIdsOf(written.get(id))]
+                : removed.has(id)
+                    ? []
+                    : base.orderedChildren(id),
+        });
+    return draft;
+}
+/** The plain value behind a tracked view (copying it records nothing); other values as they are. */
+export function untracked(value) {
+    return value && typeof value === 'object' ? (rawOfView.get(value) ?? value) : value;
+}
+/**
+ * `value` with every tracked view inside it replaced by a plain copy, recursively: what a
+ * computation hands out of its scene (a tool's result) so it outlives the scene. Copying a view
+ * reads all of it, and is recorded so.
+ */
+export function materialize(value) {
+    if (!value || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value)) {
+        const items = value.map((item) => materialize(item));
+        return (items.some((item, index) => item !== value[index]) ? items : value);
+    }
+    const isView = rawOfView.has(value);
+    if (!isView && Object.getPrototypeOf(value) !== Object.prototype)
+        return value;
+    let copy = isView ? {} : null;
+    for (const [key, item] of Object.entries(value)) {
+        const next = materialize(item);
+        if (copy)
+            copy[key] = next;
+        else if (next !== item) {
+            copy = { ...value };
+            copy[key] = next;
+        }
+    }
+    return (copy ?? value);
+}
+const readOnly = () => {
+    throw new TypeError('A scene read through a DocumentReader is read-only; write through the host.');
+};
+/**
+ * A read-only view of `raw` whose every own-field access calls `onRead(field)`. The proxy target
+ * is an empty shell, not `raw`, so frozen records stay viewable.
+ */
+function fieldView(raw, assertActive, onRead) {
+    const view = new Proxy(Object.create(null), {
+        get(_, key) {
+            assertActive();
+            if (typeof key === 'string')
+                onRead(key);
+            return Reflect.get(raw, key);
+        },
+        has(_, key) {
+            assertActive();
+            if (typeof key === 'string')
+                onRead(key);
+            return Reflect.has(raw, key);
+        },
+        ownKeys() {
+            assertActive();
+            const keys = Reflect.ownKeys(raw);
+            for (const key of keys)
+                if (typeof key === 'string')
+                    onRead(key);
+            return keys;
+        },
+        getOwnPropertyDescriptor(_, key) {
+            assertActive();
+            if (typeof key === 'string')
+                onRead(key);
+            const descriptor = Reflect.getOwnPropertyDescriptor(raw, key);
+            return (descriptor && {
+                value: descriptor.value,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+        },
+        getPrototypeOf: () => Object.prototype,
+        set: readOnly,
+        defineProperty: readOnly,
+        deleteProperty: readOnly,
+    });
+    rawOfView.set(view, raw);
+    return view;
+}
+/**
+ * A read-only view of one version of a record of entities: a key read records the entity's
+ * presence and returns its tracked view; enumerating the record records `enumerate()`. A view
+ * belongs to one version, as the record does, so identity-keyed memos stay correct.
+ */
+function recordView(current, assertActive, entity, enumerate) {
+    return new Proxy(Object.create(null), {
+        get(_, key) {
+            assertActive();
+            if (typeof key !== 'string')
+                return Reflect.get(current, key);
+            if (Object.hasOwn(current, key))
+                return entity(key, current[key]);
+            entity(key, undefined);
+            return Reflect.get(current, key);
+        },
+        has(_, key) {
+            assertActive();
+            if (typeof key === 'string')
+                entity(key, Object.hasOwn(current, key) ? current[key] : undefined);
+            return Reflect.has(current, key);
+        },
+        ownKeys() {
+            assertActive();
+            enumerate();
+            return Reflect.ownKeys(current);
+        },
+        getOwnPropertyDescriptor(_, key) {
+            assertActive();
+            if (typeof key !== 'string')
+                return Reflect.getOwnPropertyDescriptor(current, key);
+            if (!Object.hasOwn(current, key)) {
+                entity(key, undefined);
+                return undefined;
+            }
+            return {
+                value: entity(key, current[key]),
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            };
+        },
+        getPrototypeOf: () => Object.prototype,
+        set: readOnly,
+        defineProperty: readOnly,
+        deleteProperty: readOnly,
+    });
+}
+/**
+ * A reader over `source`. With a recorder, every read is recorded; without one (the editor's own
+ * runtime) it reads the raw document.
+ */
+export function createDocumentReader(source, recorder) {
+    if (!recorder)
+        return createPlainReader(source);
+    return createTrackedReader(source, recorder);
+}
+function createTrackedReader(source, recorder) {
+    const { assertActive } = source;
+    const nodeViews = new WeakMap();
+    const collectionViews = new WeakMap();
+    const trackNode = (id, raw) => {
+        recorder.node(id);
+        if (!raw)
+            return undefined;
+        let view = nodeViews.get(raw);
+        if (!view) {
+            view = fieldView(raw, assertActive, (field) => recorder.node(raw.id, field));
+            nodeViews.set(raw, view);
+        }
+        return view;
+    };
+    const trackCollection = (id, raw) => {
+        recorder.collection(id);
+        if (!raw)
+            return undefined;
+        let view = collectionViews.get(raw);
+        if (!view) {
+            view = fieldView(raw, assertActive, (field) => recorder.collection(raw.id, field));
+            collectionViews.set(raw, view);
+        }
+        return view;
+    };
+    const document = (version = {}) => ({
+        nodes: version.nodes ?? source.nodes(),
+        collections: version.collections ?? source.collections(),
+        materials: source.materials(),
+        rootNodeIds: source.rootNodeIds(),
+    });
+    const recordQuery = (query, predicate, version) => {
+        const resultIds = queryIds(document(version), {
+            entity: query,
+            predicate: (predicate ?? null),
+        });
+        recorder.query({ kind: 'query', entity: query, predicate, resultIds });
+        return resultIds;
+    };
+    // One view per version of each record, created as the reader meets it.
+    const recordViews = new WeakMap();
+    const viewOf = (raw, entity, version, kind) => {
+        let view = recordViews.get(raw);
+        if (!view) {
+            view = recordView(raw, assertActive, entity, () => recordQuery(kind, null, version));
+            recordViews.set(raw, view);
+            queriesOfRecord.set(view, {
+                query: ((selection) => queryIn(selection, version)),
+                orderedChildren: (id) => orderedChildrenIn(id, version),
+            });
+            rawOfView.set(view, raw);
+        }
+        return view;
+    };
+    function queryIn(query, version = {}) {
+        assertActive();
+        const current = document(version);
+        switch (query.entity) {
+            case 'node':
+                return recordQuery('node', query.where ?? null, version).map((id) => trackNode(id, current.nodes[id]));
+            case 'collection':
+                return recordQuery('collection', query.where ?? null, version).map((id) => trackCollection(id, current.collections[id]));
+            case 'material':
+                // Each material returned is read whole.
+                return recordQuery('material', null).map((id) => {
+                    recorder.material(id);
+                    return current.materials[id];
+                });
+            case 'root':
+                return recordQuery('root', null).flatMap((id) => trackNode(id, current.nodes[id]) ?? []);
+        }
+    }
+    function orderedChildrenIn(id, version = {}) {
+        assertActive();
+        const node = document(version).nodes[id];
+        recorder.node(id);
+        const children = childIdsOf(node);
+        recorder.order(id, children);
+        return [...children];
+    }
+    const reader = {
+        get: (id) => {
+            assertActive();
+            return trackNode(id, source.nodes()[id]);
+        },
+        query: ((selection) => queryIn(selection)),
+        orderedChildren: (id) => orderedChildrenIn(id),
+        collection: (id) => {
+            assertActive();
+            return trackCollection(id, source.collections()[id]);
+        },
+        material: (id) => {
+            assertActive();
+            recorder.material(id);
+            return source.materials()[id];
+        },
+        installedPlugins: () => {
+            assertActive();
+            recorder.installedPlugins();
+            return [...source.installedPlugins()];
+        },
+        get nodes() {
+            assertActive();
+            const raw = source.nodes();
+            return viewOf(raw, trackNode, { nodes: raw }, 'node');
+        },
+        track: (raw) => {
+            assertActive();
+            const version = raw;
+            return viewOf(version, trackNode, { nodes: version }, 'node');
+        },
+        get collections() {
+            assertActive();
+            const raw = source.collections();
+            return viewOf(raw, trackCollection, { collections: raw }, 'collection');
+        },
+    };
+    return reader;
+}
+function childIdsOf(node) {
+    return node && 'children' in node && Array.isArray(node.children)
+        ? node.children.filter((id) => typeof id === 'string')
+        : [];
+}
+function createPlainReader(source) {
+    const { assertActive } = source;
+    const document = () => ({
+        nodes: source.nodes(),
+        collections: source.collections(),
+        materials: source.materials(),
+        rootNodeIds: source.rootNodeIds(),
+    });
+    function query(query) {
+        assertActive();
+        const current = document();
+        const ids = queryIds(current, {
+            entity: query.entity,
+            predicate: ('where' in query ? (query.where ?? null) : null),
+        });
+        switch (query.entity) {
+            case 'node':
+            case 'root':
+                return ids.flatMap((id) => current.nodes[id] ?? []);
+            case 'collection':
+                return ids.map((id) => current.collections[id]);
+            case 'material':
+                return ids.map((id) => current.materials[id]);
+        }
+    }
+    return {
+        get: (id) => source.nodes()[id],
+        query: query,
+        orderedChildren: (id) => childIdsOf(source.nodes()[id]),
+        collection: (id) => source.collections()[id],
+        material: (id) => source.materials()[id],
+        installedPlugins: () => [...source.installedPlugins()],
+        get nodes() {
+            return source.nodes();
+        },
+        track: (raw) => raw,
+        get collections() {
+            return source.collections();
+        },
+    };
+}

package/dist/runtime/scene-runtime.d.ts

@@ -0,0 +1,112 @@
+import { type AgentHostRuntime } from '../agent-operations/apply-outcome.js';
+import type { AgentContext, AgentOperation, SceneChanges, SceneNodes } from '../agent-operations/types.js';
+import { type IdAllocator } from '../schema/base.js';
+import { type SceneSnapshot } from '../store/history-control.js';
+import { type SceneStore } from '../store/use-scene.js';
+import { type Dependency } from './dependencies.js';
+import { diffSceneDocuments } from './patch.js';
+import { type DocumentReader } from './reader.js';
+/** The saved scene a computation starts from: a draft revision, or an authority sequence. */
+export type SceneRevision = {
+    kind: 'draft';
+    id: string;
+    updatedAt: string;
+} | {
+    kind: 'authority';
+    seq: number;
+};
+/**
+ * What a computation knows besides the document, frozen when it starts: the floor the person was
+ * viewing, their selection and units, the catalog revision, and the node registry it ran against.
+ */
+export type ExecutionContext = {
+    activeLevelId: string | null;
+    selection: readonly string[];
+    units: 'metric' | 'imperial';
+    catalogVersion: string;
+    /** `captureRegistryVersions()` once the host's plugins are loaded. */
+    registryVersions: Record<string, string>;
+};
+/** Each registered node kind and the schema version it parses with (`plugin@version`). */
+export declare function captureRegistryVersions(): Record<string, string>;
+export declare class RegistryVersionMismatchError extends Error {
+    readonly kinds: string[];
+    constructor(kinds: string[]);
+}
+/**
+ * A scene store with the means to compute on it: the reader agent code reads through, the scope
+ * (environment, id allocator, support index) its writes run in, and the document reconciliation.
+ * The editor's store is one (`liveSceneRuntime`); a detached scene is another.
+ */
+export interface SceneRuntime {
+    readonly store: SceneStore;
+    reader(): DocumentReader;
+    /** Runs `run` in this scene's scope: its history environment, ids and support index. */
+    run<T>(run: () => T): T;
+    /** Settles every derived write owed since `before` (`reconcileDocument`), reading through `reader`. */
+    reconcile(before: SceneNodes, options?: {
+        allLevels?: boolean;
+    }): void;
+    /** Records a read the reader cannot see; absent where nothing is recorded (the editor's store). */
+    declare?(dependency: Dependency): void;
+}
+/** The editor's own store: plain reads, random ids, the editor's environment. */
+export declare const liveSceneRuntime: SceneRuntime;
+/**
+ * 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 declare function loadCanonicalSnapshot(store: SceneStore, snapshot: SceneSnapshot): void;
+/** A scene detached from the editor: computed on, then turned into a patch. */
+export interface DetachedScene extends SceneRuntime {
+    readonly base: SceneRevision;
+    readonly context: ExecutionContext;
+    /** Applies agent changes and settles their derived writes, recording what they read. */
+    host(): AgentHostRuntime;
+    /**
+     * Runs an agent operation on this scene, as `applyAgentOutcome` through `host()`, and returns its
+     * result as plain data (`materialize`) that outlives the scene.
+     */
+    execute<Input>(operation: AgentOperation<Input>, input: Input, context: AgentContext): Record<string, unknown>;
+    /** Records a read the reader cannot see: a project file, an artifact, a conservative scope. */
+    declare(dependency: Dependency): void;
+    dependencies(): Dependency[];
+    /** The document change since the snapshot, field by field, derived writes settled. */
+    patch(): ReturnType<typeof diffSceneDocuments>;
+    /** Ends the scene: every later read or write of it throws. */
+    dispose(): void;
+    readonly disposed: boolean;
+}
+/** Freezes plain data in place, deeply; returns it. */
+export declare function deepFreeze<T>(value: T): T;
+/** Applies agent changes to a store as the editor's actions do. */
+export declare function applySceneChangesToStore(store: SceneStore, changes: SceneChanges): void;
+/**
+ * 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 declare function createAgentHost(runtime: SceneRuntime): AgentHostRuntime;
+/**
+ * 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 declare function declareActionDependencies(runtime: Pick<SceneRuntime, 'store' | 'declare'>, before: SceneNodes, changes: SceneChanges): void;
+/**
+ * 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 declare function openDetachedScene(snapshot: SceneSnapshot, options: {
+    base: SceneRevision;
+    context: ExecutionContext;
+    ids: IdAllocator;
+}): DetachedScene;
+//# sourceMappingURL=scene-runtime.d.ts.map

package/dist/runtime/scene-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-runtime.d.ts","sourceRoot":"","sources":["../../src/runtime/scene-runtime.ts"],"names":[],"mappings":"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"}