@cms0/cms0 0.2.11 → 0.2.12

package/dist/cjs/provenance.cjs

@@ -0,0 +1,517 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCms0CanvasTransportEnabled = isCms0CanvasTransportEnabled;
+exports.registerCms0LiveRoot = registerCms0LiveRoot;
+exports.registerCms0CollectionItemIdentity = registerCms0CollectionItemIdentity;
+exports.readCms0CollectionItemIdentity = readCms0CollectionItemIdentity;
+exports.enableCms0ProvenanceTracking = enableCms0ProvenanceTracking;
+exports.activateCms0CanvasTransport = activateCms0CanvasTransport;
+exports.isCms0ProvenanceTrackingEnabled = isCms0ProvenanceTrackingEnabled;
+exports.attachCms0ProvenanceRoot = attachCms0ProvenanceRoot;
+exports.readCms0ProvenanceValueMeta = readCms0ProvenanceValueMeta;
+exports.unwrapCms0CanvasTransportValue = unwrapCms0CanvasTransportValue;
+exports.readCms0CanvasTransportCollectionItemId = readCms0CanvasTransportCollectionItemId;
+exports.restoreCms0CanvasTransportMetadata = restoreCms0CanvasTransportMetadata;
+exports.readCms0LiveRoots = readCms0LiveRoots;
+exports.captureCms0Provenance = captureCms0Provenance;
+const schema_descriptors_js_1 = require("./schema-descriptors.cjs");
+globalThis.__CMS0_SCHEMA_DESCRIPTOR__ = schema_descriptors_js_1.schemaDescriptor;
+globalThis.__CMS0_CANVAS_SCHEMA_DESCRIPTOR__ = schema_descriptors_js_1.schemaDescriptor;
+const CAPTURE_STACK = [];
+const ARRAY_METHOD_NAMES = new Set(Object.getOwnPropertyNames(Array.prototype));
+const TRACK_IGNORED_OBJECT_KEYS = new Set([
+    "__proto__",
+    "prototype",
+    "constructor",
+    "toJSON",
+]);
+const CMS0_CANVAS_TRANSPORT_KEY = "__cms0CanvasTransport";
+const CMS0_CANVAS_TRANSPORT_DATA_KEY = "data";
+const CMS0_CANVAS_COLLECTION_ITEM_ID_KEY = "__cms0CanvasCollectionItemId";
+let provenanceEnabled = false;
+const proxyCache = new WeakMap();
+const proxyMeta = new WeakMap();
+const collectionItemIdentity = new WeakMap();
+function isCanvasTransportEnabled() {
+    return globalThis.__CMS0_CANVAS_TRANSPORT_ENABLED__ === true;
+}
+function isCms0CanvasTransportEnabled() {
+    return isCanvasTransportEnabled();
+}
+function isRootRawPath(rawPath) {
+    return rawPath.length > 0 && !rawPath.includes(".") && !rawPath.includes("[#");
+}
+function cloneCanvasTransportValue(value, seen = new WeakMap()) {
+    if (!value || typeof value !== "object")
+        return value;
+    const cached = seen.get(value);
+    if (cached)
+        return cached;
+    if (Array.isArray(value)) {
+        const clone = [];
+        seen.set(value, clone);
+        value.forEach((item, index) => {
+            clone[index] = cloneCanvasTransportValue(item, seen);
+        });
+        return clone;
+    }
+    const clone = {};
+    seen.set(value, clone);
+    Object.entries(value).forEach(([key, nested]) => {
+        clone[key] = cloneCanvasTransportValue(nested, seen);
+    });
+    const collectionItemId = readCms0CollectionItemIdentity(value);
+    if (collectionItemId) {
+        clone[CMS0_CANVAS_COLLECTION_ITEM_ID_KEY] = collectionItemId;
+    }
+    return clone;
+}
+function wrapCanvasTransportRoot(value, rootId) {
+    return {
+        [CMS0_CANVAS_TRANSPORT_KEY]: {
+            version: 1,
+            rootId,
+        },
+        [CMS0_CANVAS_TRANSPORT_DATA_KEY]: cloneCanvasTransportValue(value),
+    };
+}
+function supportsWeakRef() {
+    return typeof WeakRef !== "undefined";
+}
+function getLiveRootStore() {
+    const existing = globalThis.__CMS0_LIVE_ROOTS__;
+    if (existing)
+        return existing;
+    const created = new Map();
+    globalThis.__CMS0_LIVE_ROOTS__ = created;
+    return created;
+}
+function derefLiveRoot(entry) {
+    if (supportsWeakRef() && entry instanceof WeakRef) {
+        return entry.deref() ?? null;
+    }
+    return entry;
+}
+function pruneDeadLiveRoots(entries) {
+    for (const entry of entries) {
+        if (!derefLiveRoot(entry)) {
+            entries.delete(entry);
+        }
+    }
+}
+function registerLiveRoot(rootId, value) {
+    const store = getLiveRootStore();
+    const entries = store.get(rootId) ?? new Set();
+    pruneDeadLiveRoots(entries);
+    for (const entry of entries) {
+        if (derefLiveRoot(entry) === value) {
+            store.set(rootId, entries);
+            return;
+        }
+    }
+    entries.add(supportsWeakRef() ? new WeakRef(value) : value);
+    store.set(rootId, entries);
+}
+function registerCms0LiveRoot(rootId, value) {
+    const normalizedRoot = typeof rootId === "string" ? rootId.trim() : "";
+    if (!normalizedRoot)
+        return;
+    registerLiveRoot(normalizedRoot, value);
+}
+function registerCms0CollectionItemIdentity(value, collectionItemId) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return;
+    const normalizedId = typeof collectionItemId === "string" ? collectionItemId.trim() : "";
+    if (!normalizedId)
+        return;
+    collectionItemIdentity.set(value, normalizedId);
+}
+function readCms0CollectionItemIdentity(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return collectionItemIdentity.get(value) ?? null;
+}
+function isNumericToken(value) {
+    return /^\d+$/.test(value);
+}
+function isItemMarkerToken(value) {
+    return /^\[#.+\]$/.test(value);
+}
+function readTrackedEntityId(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const rawId = value.id;
+    return typeof rawId === "string" && rawId.trim().length > 0 ? rawId : null;
+}
+function readTrackedCollectionItemId(value) {
+    return readCms0CollectionItemIdentity(value) ?? readTrackedEntityId(value);
+}
+function normalizeTrackedToken(target, property, value) {
+    const token = property.trim();
+    if (!token)
+        return null;
+    if (Array.isArray(target)) {
+        if (isNumericToken(token)) {
+            const entityId = readTrackedCollectionItemId(value);
+            return entityId ? `[#${entityId}]` : token;
+        }
+        if (token === "length")
+            return null;
+        if (ARRAY_METHOD_NAMES.has(token))
+            return null;
+        return null;
+    }
+    if (TRACK_IGNORED_OBJECT_KEYS.has(token))
+        return null;
+    return token;
+}
+function recordPath(pathTokens) {
+    const activeCapture = CAPTURE_STACK[CAPTURE_STACK.length - 1];
+    if (!activeCapture)
+        return;
+    const normalizedTokens = pathTokens.filter((token) => token.length > 0);
+    if (normalizedTokens.length === 0)
+        return;
+    activeCapture.paths.add(normalizedTokens.join("."));
+}
+function recordCapture(pathTokens, value) {
+    const activeCapture = CAPTURE_STACK[CAPTURE_STACK.length - 1];
+    if (!activeCapture)
+        return;
+    const normalizedTokens = pathTokens.filter((token) => token.length > 0);
+    if (normalizedTokens.length === 0)
+        return;
+    const rawPath = normalizedTokens.join(".");
+    const path = canonicalizePath(rawPath);
+    if (!path)
+        return;
+    if (!activeCapture.captures.has(rawPath)) {
+        activeCapture.captures.set(rawPath, {
+            path,
+            rawPath,
+            value,
+        });
+    }
+}
+function canonicalizePath(path) {
+    return path
+        .split(".")
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0 &&
+        !isNumericToken(token) &&
+        !isItemMarkerToken(token))
+        .join(".");
+}
+function collectCanonicalLeaves(paths) {
+    const leaves = new Set();
+    for (const rawPath of paths) {
+        const canonicalPath = canonicalizePath(rawPath);
+        if (!canonicalPath)
+            continue;
+        leaves.add(canonicalPath);
+    }
+    const ordered = Array.from(leaves).sort((a, b) => {
+        const depthA = a.split(".").length;
+        const depthB = b.split(".").length;
+        if (depthA !== depthB)
+            return depthB - depthA;
+        return a.localeCompare(b);
+    });
+    const filtered = [];
+    for (const path of ordered) {
+        const isAncestorOfKnownLeaf = filtered.some((known) => known === path || known.startsWith(`${path}.`));
+        if (isAncestorOfKnownLeaf)
+            continue;
+        filtered.push(path);
+    }
+    return filtered.sort((a, b) => a.localeCompare(b));
+}
+function expandCandidates(paths) {
+    const candidates = new Set();
+    for (const rawPath of paths) {
+        const canonicalPath = canonicalizePath(rawPath);
+        if (!canonicalPath)
+            continue;
+        const tokens = canonicalPath.split(".");
+        for (let index = 1; index <= tokens.length; index += 1) {
+            candidates.add(tokens.slice(0, index).join("."));
+        }
+    }
+    return Array.from(candidates).sort((a, b) => {
+        const depthA = a.split(".").length;
+        const depthB = b.split(".").length;
+        if (depthA !== depthB)
+            return depthA - depthB;
+        return a.localeCompare(b);
+    });
+}
+function longestCommonPrefix(paths) {
+    if (paths.length === 0)
+        return undefined;
+    const tokensList = paths.map((path) => path.split("."));
+    const first = tokensList[0];
+    if (!first)
+        return undefined;
+    const prefix = [];
+    for (let index = 0; index < first.length; index += 1) {
+        const token = first[index];
+        if (!token)
+            break;
+        const matchesAll = tokensList.every((tokens) => tokens[index] === token);
+        if (!matchesAll)
+            break;
+        prefix.push(token);
+    }
+    return prefix.length ? prefix.join(".") : undefined;
+}
+function buildMapping(paths) {
+    const leaves = collectCanonicalLeaves(paths);
+    const expanded = expandCandidates(leaves);
+    if (expanded.length === 0)
+        return null;
+    const rootCandidates = new Set();
+    expanded.forEach((candidate) => {
+        const [root] = candidate.split(".");
+        if (root)
+            rootCandidates.add(root);
+    });
+    const rootId = rootCandidates.size === 1 ? Array.from(rootCandidates)[0] : undefined;
+    const fieldId = leaves.length === 1 ? leaves[0] : undefined;
+    let scopeId;
+    if (!fieldId && leaves.length > 1) {
+        const prefix = longestCommonPrefix(leaves);
+        if (prefix && prefix.includes(".")) {
+            scopeId = prefix;
+        }
+    }
+    const candidates = expanded.length > 1 ? expanded : undefined;
+    if (fieldId) {
+        return {
+            paths: leaves,
+            fieldId,
+            scopeId,
+            rootId,
+            candidates,
+            confidence: "exact",
+        };
+    }
+    if (scopeId) {
+        return { paths: leaves, fieldId, scopeId, rootId, candidates, confidence: "scope" };
+    }
+    if (rootId) {
+        return { paths: leaves, fieldId, scopeId, rootId, candidates, confidence: "root" };
+    }
+    return {
+        paths: leaves,
+        fieldId,
+        scopeId,
+        rootId,
+        candidates: expanded,
+        confidence: "multi",
+    };
+}
+function attachCaptures(mapping, captures) {
+    if (!mapping || captures.size === 0)
+        return mapping;
+    const entityIds = {};
+    for (const capture of captures.values()) {
+        const meta = readCms0ProvenanceValueMeta(capture.value);
+        if (!meta?.entityIds)
+            continue;
+        for (const [rawPath, entityId] of Object.entries(meta.entityIds)) {
+            if (typeof entityId !== "string" || entityId.trim().length === 0)
+                continue;
+            entityIds[rawPath] = entityId;
+        }
+    }
+    return {
+        ...mapping,
+        captures: Array.from(captures.values()).sort((left, right) => {
+            const depthDelta = left.rawPath.split(".").length - right.rawPath.split(".").length;
+            if (depthDelta !== 0)
+                return depthDelta;
+            return left.rawPath.localeCompare(right.rawPath);
+        }),
+        entityIds: Object.keys(entityIds).length > 0 ? entityIds : undefined,
+    };
+}
+function buildEntityLineage(inheritedEntityIds, rawPath, value) {
+    const entityId = readTrackedEntityId(value);
+    if (!entityId) {
+        return inheritedEntityIds;
+    }
+    return {
+        ...inheritedEntityIds,
+        [rawPath]: entityId,
+    };
+}
+function wrapWithProvenance(value, pathTokens, inheritedEntityIds = {}) {
+    if (!provenanceEnabled)
+        return value;
+    if (!value || typeof value !== "object")
+        return value;
+    const objectValue = value;
+    const pathKey = pathTokens.join(".");
+    const currentEntityIds = buildEntityLineage(inheritedEntityIds, pathKey, objectValue);
+    const cachedByPath = proxyCache.get(objectValue);
+    if (cachedByPath?.has(pathKey)) {
+        return cachedByPath.get(pathKey);
+    }
+    const proxy = new Proxy(objectValue, {
+        get(target, property, receiver) {
+            if (property === "toJSON" &&
+                isCanvasTransportEnabled() &&
+                isRootRawPath(pathKey)) {
+                return () => wrapCanvasTransportRoot(target, pathKey);
+            }
+            const result = Reflect.get(target, property, receiver);
+            if (typeof property !== "string")
+                return result;
+            const trackedToken = normalizeTrackedToken(target, property, result);
+            if (!trackedToken)
+                return result;
+            const nextPath = [...pathTokens, trackedToken];
+            const wrappedResult = wrapWithProvenance(result, nextPath, buildEntityLineage(currentEntityIds, nextPath.join("."), result));
+            recordPath(nextPath);
+            recordCapture(nextPath, wrappedResult);
+            return wrappedResult;
+        },
+    });
+    const map = cachedByPath ?? new Map();
+    map.set(pathKey, proxy);
+    if (!cachedByPath) {
+        proxyCache.set(objectValue, map);
+    }
+    const collectionItemId = readCms0CollectionItemIdentity(objectValue);
+    if (collectionItemId) {
+        collectionItemIdentity.set(proxy, collectionItemId);
+    }
+    const rawPath = pathKey;
+    proxyMeta.set(proxy, {
+        path: canonicalizePath(rawPath),
+        rawPath,
+        entityIds: currentEntityIds,
+    });
+    return proxy;
+}
+function enableCms0ProvenanceTracking(enabled = true) {
+    provenanceEnabled = enabled;
+}
+function activateCms0CanvasTransport(enabled = true) {
+    globalThis.__CMS0_CANVAS_TRANSPORT_ENABLED__ = enabled;
+}
+function isCms0ProvenanceTrackingEnabled() {
+    return provenanceEnabled;
+}
+function attachCms0ProvenanceRoot(value, rootId, options) {
+    if (!provenanceEnabled)
+        return value;
+    const normalizedRoot = typeof rootId === "string" ? rootId.trim() : "";
+    if (!normalizedRoot)
+        return value;
+    const wrapped = wrapWithProvenance(value, [normalizedRoot]);
+    if (options?.registerLiveRoot !== false &&
+        wrapped &&
+        typeof wrapped === "object") {
+        registerLiveRoot(normalizedRoot, wrapped);
+    }
+    return wrapped;
+}
+function readCms0ProvenanceValueMeta(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    return proxyMeta.get(value) ?? null;
+}
+function unwrapCms0CanvasTransportValue(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const marker = value[CMS0_CANVAS_TRANSPORT_KEY];
+    const payload = value[CMS0_CANVAS_TRANSPORT_DATA_KEY];
+    if (!marker || typeof marker !== "object")
+        return null;
+    const rootId = marker.rootId;
+    const version = marker.version;
+    if (version !== 1 || typeof rootId !== "string" || rootId.trim().length === 0) {
+        return null;
+    }
+    return {
+        rootId: rootId.trim(),
+        value: payload,
+    };
+}
+function readCms0CanvasTransportCollectionItemId(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const candidate = value[CMS0_CANVAS_COLLECTION_ITEM_ID_KEY];
+    return typeof candidate === "string" && candidate.trim().length > 0
+        ? candidate.trim()
+        : null;
+}
+function restoreCanvasTransportMetadataInternal(value, visited) {
+    if (!value || typeof value !== "object")
+        return;
+    if (visited.has(value))
+        return;
+    visited.add(value);
+    if (Array.isArray(value)) {
+        value.forEach((entry) => restoreCanvasTransportMetadataInternal(entry, visited));
+        return;
+    }
+    const record = value;
+    const collectionItemId = record[CMS0_CANVAS_COLLECTION_ITEM_ID_KEY];
+    if (typeof collectionItemId === "string" && collectionItemId.trim().length > 0) {
+        registerCms0CollectionItemIdentity(record, collectionItemId);
+    }
+    delete record[CMS0_CANVAS_COLLECTION_ITEM_ID_KEY];
+    Object.values(record).forEach((entry) => restoreCanvasTransportMetadataInternal(entry, visited));
+}
+function restoreCms0CanvasTransportMetadata(value) {
+    restoreCanvasTransportMetadataInternal(value, new WeakSet());
+    return value;
+}
+function readCms0LiveRoots(rootId) {
+    const store = globalThis.__CMS0_LIVE_ROOTS__;
+    if (!store)
+        return [];
+    const rootIds = typeof rootId === "string" && rootId.trim().length > 0
+        ? [rootId.trim()]
+        : Array.from(store.keys());
+    const results = [];
+    for (const id of rootIds) {
+        const entries = store.get(id);
+        if (!entries)
+            continue;
+        pruneDeadLiveRoots(entries);
+        for (const entry of entries) {
+            const value = derefLiveRoot(entry);
+            if (!value)
+                continue;
+            results.push({ rootId: id, value });
+        }
+        if (entries.size === 0) {
+            store.delete(id);
+        }
+    }
+    return results;
+}
+globalThis.__CMS0_READ_PROVENANCE_VALUE_META__ = readCms0ProvenanceValueMeta;
+function captureCms0Provenance(evaluate) {
+    if (!provenanceEnabled) {
+        return { value: evaluate(), mapping: null };
+    }
+    const capture = {
+        paths: new Set(),
+        captures: new Map(),
+    };
+    CAPTURE_STACK.push(capture);
+    try {
+        const value = evaluate();
+        return {
+            value,
+            mapping: attachCaptures(buildMapping(capture.paths), capture.captures),
+        };
+    }
+    finally {
+        CAPTURE_STACK.pop();
+    }
+}

package/dist/esm/custom-types/registry.js

@@ -15,6 +15,10 @@ const fileFieldDescriptors = {
 const fileDescriptor = {
     kind: "model",
     properties: fileFieldDescriptors,
+    presentation: {
+        kind: "asset",
+        assetKind: "file",
+    },
 };
 const imageDescriptor = {
     kind: "model",
@@ -24,6 +28,10 @@ const imageDescriptor = {
         height: primitive("number"),
         alt: { kind: "primitive", type: "string", optional: true, nullable: false },
     },
+    presentation: {
+        kind: "asset",
+        assetKind: "image",
+    },
 };
 const videoDescriptor = {
     kind: "model",
@@ -34,6 +42,10 @@ const videoDescriptor = {
         length: primitive("number"),
         alt: { kind: "primitive", type: "string", optional: true, nullable: false },
     },
+    presentation: {
+        kind: "asset",
+        assetKind: "video",
+    },
 };
 const richTextDescriptor = {
     kind: "primitive",