@pascal-app/core 1.0.6 → 1.0.7

package/dist/runtime/apply.js

@@ -0,0 +1,274 @@
+import { nextSceneOperationState, } from '../store/use-scene.js';
+import { levelOf, queryIds } from './dependencies.js';
+import { childIdsOf, fieldChanges, sameValue } from './patch.js';
+const nodeOf = (doc, id) => doc.nodes[id];
+const fieldOf = (node, field) => node ? node[field] : undefined;
+/** Ids of nodes that differ between two documents (created, deleted or changed). */
+function changedNodeIds(base, current) {
+    const ids = [];
+    for (const id of new Set([...Object.keys(base.nodes), ...Object.keys(current.nodes)])) {
+        const before = nodeOf(base, id);
+        const after = nodeOf(current, id);
+        if (before !== after && !sameValue(before, after))
+            ids.push(id);
+    }
+    return ids;
+}
+function ancestorIds(doc, id) {
+    const ids = [];
+    let parentId = id ? nodeOf(doc, id)?.parentId : null;
+    while (parentId && !ids.includes(parentId)) {
+        ids.push(parentId);
+        parentId = nodeOf(doc, parentId)?.parentId;
+    }
+    return ids;
+}
+function documentChanged(base, current) {
+    return (changedNodeIds(base, current).length > 0 ||
+        !sameValue(base.rootNodeIds, current.rootNodeIds) ||
+        !sameValue(base.collections, current.collections) ||
+        !sameValue(base.materials, current.materials) ||
+        !sameValue(base.installedPlugins, current.installedPlugins));
+}
+function dependencyChanges(dependency, base, current, external, changedIds) {
+    const changed = (entity) => [
+        { ...entity, reason: 'dependency' },
+    ];
+    switch (dependency.kind) {
+        case 'node': {
+            const before = nodeOf(base, dependency.id);
+            const after = nodeOf(current, dependency.id);
+            if (!before !== !after)
+                return changed({ kind: 'node', id: dependency.id });
+            return dependency.fields.flatMap((field) => sameValue(fieldOf(before, field), fieldOf(after, field))
+                ? []
+                : changed({ kind: 'node', id: dependency.id, field }));
+        }
+        case 'query':
+            return sameValue(queryIds(base, dependency), queryIds(current, dependency))
+                ? []
+                : changed({ kind: 'query', id: dependency.entity });
+        case 'order':
+            return sameValue(childIdsOf(nodeOf(base, dependency.parentId)), childIdsOf(nodeOf(current, dependency.parentId)))
+                ? []
+                : changed({ kind: 'order', id: dependency.parentId });
+        case 'collection': {
+            const before = base.collections[dependency.id];
+            const after = current.collections[dependency.id];
+            if (!before !== !after)
+                return changed({ kind: 'collection', id: dependency.id });
+            return dependency.fields.flatMap((field) => sameValue(before?.[field], after?.[field])
+                ? []
+                : changed({ kind: 'collection', id: dependency.id, field }));
+        }
+        case 'material':
+            return sameValue(base.materials[dependency.id], current.materials[dependency.id])
+                ? []
+                : changed({ kind: 'material', id: dependency.id });
+        case 'plugins':
+            return sameValue(base.installedPlugins, current.installedPlugins) &&
+                (base.hasExplicitPluginInstallState ?? false) ===
+                    (current.hasExplicitPluginInstallState ?? false)
+                ? []
+                : changed({ kind: 'plugins' });
+        case 'file':
+            return external.fileUpdatedAt?.(dependency.assetId) === dependency.updatedAt
+                ? []
+                : changed({ kind: 'file', id: dependency.assetId });
+        case 'artifact':
+            return external.artifactExists?.(dependency.sha256)
+                ? []
+                : changed({ kind: 'artifact', id: dependency.sha256 });
+        case 'scope': {
+            if (dependency.whole)
+                return documentChanged(base, current) ? changed({ kind: 'scope' }) : [];
+            const level = dependency.level;
+            // The level's own content, and what it stands on: its building and site (transforms,
+            // sculpted terrain) reach every support answer on it.
+            const ancestors = new Set([...ancestorIds(base, level), ...ancestorIds(current, level)]);
+            const touched = changedIds().some((id) => id === level ||
+                ancestors.has(id) ||
+                levelOf(base.nodes, id) === level ||
+                levelOf(current.nodes, id) === level);
+            return touched ? changed({ kind: 'scope', id: level }) : [];
+        }
+    }
+}
+function writeChanges(patch, base, current) {
+    const changed = [];
+    const write = (entity) => changed.push({ ...entity, reason: 'write' });
+    const createdIds = new Set(patch.nodeCreates.map(({ node }) => node.id));
+    for (const { id, data, removeFields } of patch.nodeUpdates) {
+        const before = nodeOf(base, id);
+        const after = nodeOf(current, id);
+        if (!after) {
+            write({ kind: 'node', id });
+            continue;
+        }
+        const written = { ...data };
+        for (const field of removeFields)
+            written[field] = undefined;
+        for (const [field, value] of Object.entries(written)) {
+            const theirs = fieldOf(after, field);
+            if (!sameValue(fieldOf(before, field), theirs) && !sameValue(theirs, value))
+                write({ kind: 'node', id, field });
+        }
+    }
+    for (const { node } of patch.nodeDeletes) {
+        const after = nodeOf(current, node.id);
+        if (!after || !sameValue(nodeOf(base, node.id), after))
+            write({ kind: 'node', id: node.id });
+    }
+    for (const { node } of patch.nodeCreates) {
+        if (nodeOf(current, node.id))
+            write({ kind: 'node', id: node.id });
+        const parentId = node.parentId;
+        if (parentId && !createdIds.has(parentId) && !nodeOf(current, parentId))
+            write({ kind: 'node', id: parentId });
+    }
+    for (const { id, collection } of patch.collectionChanges ?? []) {
+        const before = base.collections[id];
+        const after = current.collections[id];
+        if (collection === null || !before) {
+            if (!sameValue(before, after) && !sameValue(after, collection))
+                write({ kind: 'collection', id });
+            continue;
+        }
+        if (!after) {
+            write({ kind: 'collection', id });
+            continue;
+        }
+        const { data, removeFields } = fieldChanges(before, collection);
+        const written = { ...data };
+        for (const field of removeFields)
+            written[field] = undefined;
+        for (const [field, value] of Object.entries(written)) {
+            const theirs = after[field];
+            if (!sameValue(before[field], theirs) &&
+                !sameValue(theirs, value))
+                write({ kind: 'collection', id, field });
+        }
+    }
+    for (const { id, material } of patch.materialChanges) {
+        const after = current.materials[id];
+        if (!sameValue(base.materials[id], after) && !sameValue(after, material ?? undefined))
+            write({ kind: 'material', id });
+    }
+    if ((patch.pluginInstallState || patch.pluginChanges?.length) &&
+        !sameValue(base.installedPlugins, current.installedPlugins))
+        write({ kind: 'plugins' });
+    return changed;
+}
+/**
+ * Where a patch's created siblings go among `currentSiblings`: each after the sibling it followed
+ * in the patch's own result (the nearest earlier one still there), so creates made independently
+ * on the same parent all keep their place.
+ */
+function rebasedCreates(intended, currentSiblings, creates) {
+    const created = new Set(creates.map(({ node }) => node.id));
+    const present = new Set(currentSiblings);
+    const after = new Map();
+    let anchor = null;
+    for (const id of intended) {
+        if (created.has(id)) {
+            const list = after.get(anchor) ?? [];
+            list.push(id);
+            after.set(anchor, list);
+        }
+        else if (present.has(id))
+            anchor = id;
+    }
+    const final = [...(after.get(null) ?? [])];
+    for (const id of currentSiblings)
+        final.push(id, ...(after.get(id) ?? []));
+    return creates.map((create) => ({ node: create.node, position: final.indexOf(create.node.id) }));
+}
+/** The patch with its structural positions and collection writes moved onto `current`. */
+function rebase(patch, base, current) {
+    const deleted = new Set(patch.nodeDeletes.map(({ node }) => node.id));
+    const created = new Set(patch.nodeCreates.map(({ node }) => node.id));
+    const childUpdates = new Map(patch.nodeUpdates.flatMap(({ id, data }) => 'children' in data ? [[id, data.children]] : []));
+    const siblingsOf = (doc, parentId) => (parentId ? childIdsOf(nodeOf(doc, parentId)) : doc.rootNodeIds);
+    const nodeDeletes = patch.nodeDeletes.map(({ node }) => {
+        const theirs = nodeOf(current, node.id);
+        const parentId = theirs.parentId ?? null;
+        return { node: theirs, position: siblingsOf(current, parentId).indexOf(node.id) };
+    });
+    const createsByParent = new Map();
+    const nodeCreates = [];
+    for (const create of patch.nodeCreates) {
+        const parentId = create.node.parentId ?? null;
+        if (parentId && created.has(parentId)) {
+            nodeCreates.push(create);
+            continue;
+        }
+        const list = createsByParent.get(parentId) ?? [];
+        list.push(create);
+        createsByParent.set(parentId, list);
+    }
+    for (const [parentId, creates] of createsByParent) {
+        const reordered = parentId ? childUpdates.get(parentId) : undefined;
+        const kept = (siblings) => reordered ?? siblings.filter((id) => !deleted.has(id));
+        const intended = [...kept(siblingsOf(base, parentId))];
+        for (const create of [...creates].sort((a, b) => a.position - b.position))
+            intended.splice(create.position, 0, create.node.id);
+        nodeCreates.push(...rebasedCreates(intended, kept(siblingsOf(current, parentId)), creates));
+    }
+    const collectionChanges = (patch.collectionChanges ?? []).map(({ id, collection }) => {
+        const before = base.collections[id];
+        const after = current.collections[id];
+        if (!(collection && before && after))
+            return { id, collection };
+        const { data, removeFields } = fieldChanges(before, collection);
+        const merged = { ...after, ...data };
+        for (const field of removeFields)
+            delete merged[field];
+        return { id, collection: merged };
+    });
+    return {
+        ...patch,
+        nodeCreates,
+        nodeDeletes,
+        ...(patch.collectionChanges ? { collectionChanges } : {}),
+    };
+}
+/**
+ * Applies a patch computed from `baseDoc` to `current`, the scene as it is now, or says what
+ * changed meanwhile so it cannot be:
+ *
+ * - every dependency (field, query membership with absent matches, order, collection, material,
+ *   plugins, file, artifact, scope) is compared between `baseDoc` and `current`;
+ * - every field the patch writes must not have been changed meanwhile to another value;
+ * - otherwise the patch lands field by field: other fields others changed on the same node or
+ *   collection are kept, and a parent's children created independently keep their place.
+ *
+ * Returns the next document and the patch rebased onto `current` (what an editor applies).
+ */
+export function applyPatchWithDependencies(current, patch, dependencies, baseDoc, external = {}) {
+    let changedIds = null;
+    const lazyChangedIds = () => {
+        changedIds ??= changedNodeIds(baseDoc, current);
+        return changedIds;
+    };
+    const changed = [
+        ...dependencies.flatMap((dependency) => dependencyChanges(dependency, baseDoc, current, external, lazyChangedIds)),
+        ...writeChanges(patch, baseDoc, current),
+    ];
+    if (changed.length)
+        return { ok: false, changed: dedupe(changed) };
+    const rebased = rebase(patch, baseDoc, current);
+    const next = nextSceneOperationState(current, rebased);
+    if (!next)
+        return { ok: false, changed: [{ kind: 'patch', reason: 'invalid' }] };
+    return { ok: true, next: { ...current, ...next }, patch: rebased };
+}
+function dedupe(changed) {
+    const seen = new Set();
+    return changed.filter((entity) => {
+        const key = JSON.stringify(entity);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}

package/dist/runtime/dependencies.d.ts

@@ -0,0 +1,97 @@
+import type { AnyNode, Collection } from '../schema/index.js';
+/** Nodes a query selects: every node, or those of a kind and/or under a parent (`null`: roots). */
+export type NodePredicate = {
+    type?: string | readonly string[];
+    parentId?: string | null;
+};
+/** Collections a query selects: by name (case-insensitive) and/or template. */
+export type CollectionPredicate = {
+    name?: string;
+    template?: string;
+};
+export type EntityQuery = {
+    entity: 'node';
+    where?: NodePredicate;
+} | {
+    entity: 'collection';
+    where?: CollectionPredicate;
+} | {
+    entity: 'material';
+} | {
+    entity: 'root';
+};
+/**
+ * What a computation read, recorded so a later apply can tell whether the scene it read still
+ * holds. Every dependency is compared between the scene the computation started from and the
+ * scene at apply time; any difference is a conflict.
+ *
+ * - `node`: the node's presence, and the fields read (top level; `[]` when only its presence was).
+ * - `query`: the ids an entity query matched, absent matches included (`[]` when none did).
+ * - `order`: a parent's children, in order, where the order was consumed.
+ * - `collection`: a collection's presence and the fields read. `material`: a material's record.
+ * - `plugins`: the installed plugin list. `file` and `artifact`: a project file at a revision,
+ *   a stored artifact, declared by the host that read them.
+ * - `scope`: a conservative fallback for reads the recorder cannot see: everything on a level,
+ *   or the whole document.
+ */
+export type Dependency = {
+    kind: 'node';
+    id: string;
+    fields: readonly string[];
+} | {
+    kind: 'query';
+    entity: 'node';
+    predicate: NodePredicate | null;
+    resultIds: readonly string[];
+} | {
+    kind: 'query';
+    entity: 'collection';
+    predicate: CollectionPredicate | null;
+    resultIds: readonly string[];
+} | {
+    kind: 'query';
+    entity: 'material' | 'root';
+    predicate: null;
+    resultIds: readonly string[];
+} | {
+    kind: 'order';
+    parentId: string;
+    childIds: readonly string[];
+} | {
+    kind: 'collection';
+    id: string;
+    fields: readonly string[];
+} | {
+    kind: 'material';
+    id: string;
+} | {
+    kind: 'plugins';
+} | {
+    kind: 'file';
+    assetId: string;
+    updatedAt: string;
+} | {
+    kind: 'artifact';
+    sha256: string;
+} | {
+    kind: 'scope';
+    level?: string;
+    whole?: true;
+};
+export type QueryDependency = Extract<Dependency, {
+    kind: 'query';
+}>;
+export declare function matchesNodePredicate(node: AnyNode, predicate: NodePredicate | null): boolean;
+export declare function matchesCollectionPredicate(collection: Collection, predicate: CollectionPredicate | null): boolean;
+/** The ids `query` selects in `doc`, in the document's own order. */
+/** The parts of a document queries read. */
+export type DocumentParts = {
+    nodes: Readonly<Record<string, AnyNode>>;
+    collections: Readonly<Record<string, Collection>>;
+    materials: Readonly<Record<string, unknown>>;
+    rootNodeIds: readonly string[];
+};
+export declare function queryIds(doc: DocumentParts, query: Pick<QueryDependency, 'entity' | 'predicate'>): string[];
+/** The level a node belongs to in `nodes`, or null outside every level. */
+export declare function levelOf(nodes: Readonly<Record<string, AnyNode>>, id: string): string | null;
+//# sourceMappingURL=dependencies.d.ts.map

package/dist/runtime/dependencies.d.ts.map

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

package/dist/runtime/dependencies.js

@@ -0,0 +1,42 @@
+import { findLevelAncestorId } from '../lib/node-ancestry.js';
+export function matchesNodePredicate(node, predicate) {
+    if (!predicate)
+        return true;
+    const { type, parentId } = predicate;
+    if (type !== undefined &&
+        !(typeof type === 'string' ? node.type === type : type.includes(node.type)))
+        return false;
+    if (parentId !== undefined && (node.parentId ?? null) !== parentId)
+        return false;
+    return true;
+}
+export function matchesCollectionPredicate(collection, predicate) {
+    if (!predicate)
+        return true;
+    if (predicate.name !== undefined &&
+        collection.name.toLowerCase() !== predicate.name.toLowerCase())
+        return false;
+    if (predicate.template !== undefined && collection.template !== predicate.template)
+        return false;
+    return true;
+}
+export function queryIds(doc, query) {
+    switch (query.entity) {
+        case 'node':
+            return Object.values(doc.nodes)
+                .filter((node) => matchesNodePredicate(node, query.predicate))
+                .map((node) => node.id);
+        case 'collection':
+            return Object.values(doc.collections)
+                .filter((collection) => matchesCollectionPredicate(collection, query.predicate))
+                .map((collection) => collection.id);
+        case 'material':
+            return Object.keys(doc.materials);
+        case 'root':
+            return [...doc.rootNodeIds];
+    }
+}
+/** The level a node belongs to in `nodes`, or null outside every level. */
+export function levelOf(nodes, id) {
+    return findLevelAncestorId(id, nodes);
+}

package/dist/runtime/ids.d.ts

@@ -0,0 +1,11 @@
+import type { IdAllocator } from '../schema/base.js';
+export { type IdAllocator, withIdAllocator } from '../schema/base.js';
+/** SHA-256 of `text` (UTF-8), synchronously: ids are minted inside synchronous store writes. */
+export declare function sha256(text: string): Uint8Array;
+/**
+ * Deterministic ids for one effect: the n-th id it asks for is `prefix_` and 16 base-36
+ * characters of SHA-256(`effectId:n`), the shape random ids have. Recomputing the same effect from
+ * the same scene allocates the same ids, so a retried commit is idempotent.
+ */
+export declare function effectIds(effectId: string): IdAllocator;
+//# sourceMappingURL=ids.d.ts.map

package/dist/runtime/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../src/runtime/ids.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAEjD,OAAO,EAAE,KAAK,WAAW,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAalE,gGAAgG;AAChG,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAkD/C;AAID;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAQvD"}

package/dist/runtime/ids.js

@@ -0,0 +1,80 @@
+export { withIdAllocator } from '../schema/base.js';
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+/** SHA-256 of `text` (UTF-8), synchronously: ids are minted inside synchronous store writes. */
+export function sha256(text) {
+    const data = new TextEncoder().encode(text);
+    const length = Math.ceil((data.length + 9) / 64) * 64;
+    const bytes = new Uint8Array(length);
+    bytes.set(data);
+    bytes[data.length] = 0x80;
+    const view = new DataView(bytes.buffer);
+    view.setUint32(length - 8, Math.floor((data.length * 8) / 2 ** 32));
+    view.setUint32(length - 4, (data.length * 8) >>> 0);
+    const hash = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const w = new Uint32Array(64);
+    const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+    for (let offset = 0; offset < length; offset += 64) {
+        for (let i = 0; i < 16; i++)
+            w[i] = view.getUint32(offset + i * 4);
+        for (let i = 16; i < 64; i++) {
+            const a = w[i - 15];
+            const b = w[i - 2];
+            const s0 = rotr(a, 7) ^ rotr(a, 18) ^ (a >>> 3);
+            const s1 = rotr(b, 17) ^ rotr(b, 19) ^ (b >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
+        }
+        let [a, b, c, d, e, f, g, h] = hash;
+        for (let i = 0; i < 64; i++) {
+            const t1 = (h +
+                (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) +
+                ((e & f) ^ (~e & g)) +
+                K[i] +
+                w[i]) >>>
+                0;
+            const t2 = ((rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        const next = [a, b, c, d, e, f, g, h];
+        for (let i = 0; i < 8; i++)
+            hash[i] = (hash[i] + next[i]) >>> 0;
+    }
+    const out = new Uint8Array(32);
+    const outView = new DataView(out.buffer);
+    for (let i = 0; i < 8; i++)
+        outView.setUint32(i * 4, hash[i]);
+    return out;
+}
+const ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
+/**
+ * Deterministic ids for one effect: the n-th id it asks for is `prefix_` and 16 base-36
+ * characters of SHA-256(`effectId:n`), the shape random ids have. Recomputing the same effect from
+ * the same scene allocates the same ids, so a retried commit is idempotent.
+ */
+export function effectIds(effectId) {
+    let counter = 0;
+    return (prefix) => {
+        const digest = sha256(`${effectId}:${counter++}`);
+        let suffix = '';
+        for (let i = 0; i < 16; i++)
+            suffix += ALPHABET[digest[i] % ALPHABET.length];
+        return `${prefix}_${suffix}`;
+    };
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,14 @@
+export type { AgentHostRuntime } from '../agent-operations/apply-outcome.js';
+export { isSettlingDocument, runSettlingDocument } from '../store/document-settling.js';
+export type { SceneCommit, SceneCommitListener, SceneSnapshot } from '../store/history-control.js';
+export { createSceneEnvironment, type SceneEnvironment, SceneEnvironmentDisposedError, } from '../store/scene-environment.js';
+export { createSceneStore, nextSceneOperationState, runAsSettledSceneStep, type SceneOperationPatch, type SceneStore, sceneDocumentOf, } from '../store/use-scene.js';
+export { reconcileDocument } from '../systems/document-reconcile.js';
+export * from './apply.js';
+export * from './dependencies.js';
+export { effectIds, type IdAllocator, sha256, withIdAllocator } from './ids.js';
+export { orderedChildIds, queryCollections, queryNodes } from './node-queries.js';
+export { diffSceneDocuments, isEmptyScenePatch, UnexpressiblePatchError } from './patch.js';
+export { createDocumentReader, DependencyRecorder, type DocumentReader, type DocumentSource, draftOf, materialize, readerOf, untracked, } from './reader.js';
+export * from './scene-runtime.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAA;AACzE,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AACpF,YAAY,EAAE,WAAW,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAC/F,OAAO,EACL,sBAAsB,EACtB,KAAK,gBAAgB,EACrB,6BAA6B,GAC9B,MAAM,4BAA4B,CAAA;AACnC,OAAO,EACL,gBAAgB,EAChB,uBAAuB,EACvB,qBAAqB,EACrB,KAAK,mBAAmB,EACxB,KAAK,UAAU,EACf,eAAe,GAChB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAA;AACjE,cAAc,SAAS,CAAA;AACvB,cAAc,gBAAgB,CAAA;AAC9B,OAAO,EAAE,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,OAAO,CAAA;AAC5E,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAC9E,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAA;AACxF,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,OAAO,EACP,WAAW,EACX,QAAQ,EACR,SAAS,GACV,MAAM,UAAU,CAAA;AACjB,cAAc,iBAAiB,CAAA"}

package/dist/runtime/index.js

@@ -0,0 +1,11 @@
+export { isSettlingDocument, runSettlingDocument } from '../store/document-settling.js';
+export { createSceneEnvironment, SceneEnvironmentDisposedError, } from '../store/scene-environment.js';
+export { createSceneStore, nextSceneOperationState, runAsSettledSceneStep, sceneDocumentOf, } from '../store/use-scene.js';
+export { reconcileDocument } from '../systems/document-reconcile.js';
+export * from './apply.js';
+export * from './dependencies.js';
+export { effectIds, sha256, withIdAllocator } from './ids.js';
+export { orderedChildIds, queryCollections, queryNodes } from './node-queries.js';
+export { diffSceneDocuments, isEmptyScenePatch, UnexpressiblePatchError } from './patch.js';
+export { createDocumentReader, DependencyRecorder, draftOf, materialize, readerOf, untracked, } from './reader.js';
+export * from './scene-runtime.js';

package/dist/runtime/node-queries.d.ts

@@ -0,0 +1,16 @@
+import type { SceneNodes } from '../agent-operations/types.js';
+import type { AnyNode, Collection } from '../schema/index.js';
+import { type CollectionPredicate, type NodePredicate } from './dependencies.js';
+/**
+ * The nodes `where` selects, in scene order. On a detached scene this records the selection (its
+ * members, absent ones included) instead of a read of every node, so an unrelated node created
+ * meanwhile does not invalidate the operation.
+ */
+export declare function queryNodes<T extends AnyNode = AnyNode>(nodes: SceneNodes, where: NodePredicate & {
+    type?: T['type'] | readonly T['type'][];
+}): T[];
+/** A node's children in order, recorded as an ordered read: for results that depend on order. */
+export declare function orderedChildIds(nodes: SceneNodes, id: string): string[];
+/** The collections `where` selects (by name, case-insensitive, or template), recorded like `queryNodes`. */
+export declare function queryCollections(collections: Readonly<Record<string, Collection>>, where: CollectionPredicate): Collection[];
+//# sourceMappingURL=node-queries.d.ts.map

package/dist/runtime/node-queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-queries.d.ts","sourceRoot":"","sources":["../../src/runtime/node-queries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAC3D,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AACpD,OAAO,EACL,KAAK,mBAAmB,EAGxB,KAAK,aAAa,EACnB,MAAM,gBAAgB,CAAA;AAGvB;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,EACpD,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,aAAa,GAAG;IAAE,IAAI,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,CAAC,MAAM,CAAC,EAAE,CAAA;CAAE,GACjE,CAAC,EAAE,CAIL;AAED,iGAAiG;AACjG,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAOvE;AAED,4GAA4G;AAC5G,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,EACjD,KAAK,EAAE,mBAAmB,GACzB,UAAU,EAAE,CAMd"}

package/dist/runtime/node-queries.js

@@ -0,0 +1,30 @@
+import { matchesCollectionPredicate, matchesNodePredicate, } from './dependencies.js';
+import { readerOf } from './reader.js';
+/**
+ * The nodes `where` selects, in scene order. On a detached scene this records the selection (its
+ * members, absent ones included) instead of a read of every node, so an unrelated node created
+ * meanwhile does not invalidate the operation.
+ */
+export function queryNodes(nodes, where) {
+    const reader = readerOf(nodes);
+    if (reader)
+        return reader.query({ entity: 'node', where });
+    return Object.values(nodes).filter((node) => matchesNodePredicate(node, where));
+}
+/** A node's children in order, recorded as an ordered read: for results that depend on order. */
+export function orderedChildIds(nodes, id) {
+    const reader = readerOf(nodes);
+    if (reader)
+        return reader.orderedChildren(id);
+    const node = nodes[id];
+    return node && 'children' in node && Array.isArray(node.children)
+        ? node.children.filter((child) => typeof child === 'string')
+        : [];
+}
+/** The collections `where` selects (by name, case-insensitive, or template), recorded like `queryNodes`. */
+export function queryCollections(collections, where) {
+    const reader = readerOf(collections);
+    if (reader)
+        return reader.query({ entity: 'collection', where });
+    return Object.values(collections).filter((collection) => matchesCollectionPredicate(collection, where));
+}

package/dist/runtime/patch.d.ts

@@ -0,0 +1,26 @@
+import type { AnyNode, AnyNodeId } from '../schema/index.js';
+import type { SceneSnapshot } from '../store/history-control.js';
+import { type SceneOperationPatch } from '../store/use-scene.js';
+/** Structural equality of document values; a key holding `undefined` counts as absent. */
+export declare function sameValue(left: unknown, right: unknown): boolean;
+export declare function childIdsOf(node: AnyNode | undefined): AnyNodeId[];
+export declare class UnexpressiblePatchError extends Error {
+    constructor(message: string);
+}
+/** The fields of `next` that differ from `base`, and those `next` no longer has. */
+export declare function fieldChanges(base: Readonly<Record<string, unknown>>, next: Readonly<Record<string, unknown>>, ignore?: readonly string[]): {
+    data: Record<string, unknown>;
+    removeFields: string[];
+};
+/**
+ * The patch that turns `base` into `next`, field by field: created nodes with the position they
+ * take among their siblings, deleted nodes as they were and where, each changed node field (and
+ * the fields removed), changed materials, collections and plugin state. A parent's `children` is
+ * written only where creates and deletes do not already account for it (a reorder). The patch is
+ * checked by applying it to `base`; one that does not land exactly on `next` (a reordering of the
+ * roots, which a patch cannot express) throws `UnexpressiblePatchError`.
+ */
+export declare function diffSceneDocuments(base: SceneSnapshot, next: SceneSnapshot): SceneOperationPatch;
+/** Whether a patch changes nothing. */
+export declare function isEmptyScenePatch(patch: SceneOperationPatch): boolean;
+//# sourceMappingURL=patch.d.ts.map

package/dist/runtime/patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch.d.ts","sourceRoot":"","sources":["../../src/runtime/patch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAc,MAAM,WAAW,CAAA;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAC7D,OAAO,EAML,KAAK,mBAAmB,EACzB,MAAM,oBAAoB,CAAA;AAE3B,0FAA0F;AAC1F,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAiBhE;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,EAAE,CAIjE;AASD,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED,oFAAoF;AACpF,wBAAgB,YAAY,CAC1B,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACvC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACvC,MAAM,GAAE,SAAS,MAAM,EAAO,GAC7B;IAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CAAE,CAS3D;AAUD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,aAAa,GAAG,mBAAmB,CAuFhG;AAED,uCAAuC;AACvC,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAUrE"}