@cms0/cms0 0.2.17 → 0.2.19

package/dist/cjs/libs/cli/watcher.cjs

@@ -7,13 +7,13 @@ exports.startWatcher = startWatcher;
 // File watcher that rebuilds descriptors on entry changes.
 const chokidar_1 = __importDefault(require("chokidar"));
 const build_js_1 = require("./build.cjs");
-function startWatcher(resolved, afterBuild) {
+function startWatcher(resolved, afterBuild, browserTarget = "sidecar", runInitialBuild = true) {
     const watcher = chokidar_1.default.watch([resolved.entryFile], {
         ignoreInitial: false,
     });
     const run = (after) => {
         try {
-            const descriptor = (0, build_js_1.buildOnce)(resolved);
+            const descriptor = (0, build_js_1.buildOnce)(resolved, browserTarget);
             if (after) {
                 Promise.resolve(after(descriptor)).catch((err) => {
                     console.error("cms0: post-build hook failed", err);
@@ -25,7 +25,9 @@ function startWatcher(resolved, afterBuild) {
         }
     };
     // Trigger a build on startup and whenever the entry file changes.
-    watcher.on("ready", () => run(afterBuild));
+    if (runInitialBuild) {
+        watcher.on("ready", () => run(afterBuild));
+    }
     watcher.on("change", () => run(afterBuild));
     watcher.on("error", (error) => {
         console.error("cms0: watcher error", error);

package/dist/cjs/provenance.cjs

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isCms0CanvasTransportEnabled = isCms0CanvasTransportEnabled;
+exports.dehydrateCms0CanvasTransportValue = dehydrateCms0CanvasTransportValue;
+exports.dehydrateCms0CanvasVisibleValue = dehydrateCms0CanvasVisibleValue;
 exports.registerCms0LiveRoot = registerCms0LiveRoot;
 exports.registerCms0CollectionItemIdentity = registerCms0CollectionItemIdentity;
 exports.readCms0CollectionItemIdentity = readCms0CollectionItemIdentity;
@@ -14,9 +16,6 @@ exports.readCms0CanvasTransportCollectionItemId = readCms0CanvasTransportCollect
 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([
@@ -41,9 +40,26 @@ function isCms0CanvasTransportEnabled() {
 function isRootRawPath(rawPath) {
     return rawPath.length > 0 && !rawPath.includes(".") && !rawPath.includes("[#");
 }
-function cloneCanvasTransportValue(value, seen = new WeakMap()) {
+function isWalkableCanvasTransportValue(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    if (Array.isArray(value))
+        return true;
+    const record = value;
+    if ("$$typeof" in record || "__v_isVNode" in record || "_owner" in record) {
+        return false;
+    }
+    if (typeof record.then === "function") {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function cloneCanvasTransportValue(value, seen = new WeakMap(), options = {}) {
     if (!value || typeof value !== "object")
         return value;
+    if (!isWalkableCanvasTransportValue(value))
+        return undefined;
     const cached = seen.get(value);
     if (cached)
         return cached;
@@ -51,19 +67,48 @@ function cloneCanvasTransportValue(value, seen = new WeakMap()) {
         const clone = [];
         seen.set(value, clone);
         value.forEach((item, index) => {
-            clone[index] = cloneCanvasTransportValue(item, seen);
+            clone[index] = cloneCanvasTransportValue(item, seen, options);
         });
+        const collectionItemId = readCms0CollectionItemIdentity(value);
+        if (collectionItemId) {
+            collectionItemIdentity.set(clone, collectionItemId);
+        }
+        if (options.attachVisibleProvenance) {
+            const meta = readCms0ProvenanceValueMeta(value);
+            if (meta?.rawPath) {
+                const wrapped = attachCms0ProvenanceRoot(clone, meta.rawPath, {
+                    registerLiveRoot: false,
+                    transportSerializable: options.transportSerializable,
+                });
+                seen.set(value, wrapped);
+                return wrapped;
+            }
+        }
         return clone;
     }
     const clone = {};
     seen.set(value, clone);
     Object.entries(value).forEach(([key, nested]) => {
-        clone[key] = cloneCanvasTransportValue(nested, seen);
+        clone[key] = cloneCanvasTransportValue(nested, seen, options);
     });
     const collectionItemId = readCms0CollectionItemIdentity(value);
-    if (collectionItemId) {
+    if (options.includeCollectionItemId !== false && collectionItemId) {
         clone[CMS0_CANVAS_COLLECTION_ITEM_ID_KEY] = collectionItemId;
     }
+    if (collectionItemId) {
+        collectionItemIdentity.set(clone, collectionItemId);
+    }
+    if (options.attachVisibleProvenance) {
+        const meta = readCms0ProvenanceValueMeta(value);
+        if (meta?.rawPath) {
+            const wrapped = attachCms0ProvenanceRoot(clone, meta.rawPath, {
+                registerLiveRoot: false,
+                transportSerializable: options.transportSerializable,
+            });
+            seen.set(value, wrapped);
+            return wrapped;
+        }
+    }
     return clone;
 }
 function wrapCanvasTransportRoot(value, rootId) {
@@ -75,6 +120,28 @@ function wrapCanvasTransportRoot(value, rootId) {
         [CMS0_CANVAS_TRANSPORT_DATA_KEY]: cloneCanvasTransportValue(value),
     };
 }
+function dehydrateCms0CanvasTransportValue(value) {
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    const meta = readCms0ProvenanceValueMeta(value);
+    if (meta?.rawPath) {
+        return wrapCanvasTransportRoot(value, meta.rawPath);
+    }
+    return cloneCanvasTransportValue(value, new WeakMap(), {
+        includeCollectionItemId: true,
+    });
+}
+function dehydrateCms0CanvasVisibleValue(value) {
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    return cloneCanvasTransportValue(value, new WeakMap(), {
+        attachVisibleProvenance: true,
+        includeCollectionItemId: false,
+        transportSerializable: false,
+    });
+}
 function supportsWeakRef() {
     return typeof WeakRef !== "undefined";
 }
@@ -345,7 +412,7 @@ function buildEntityLineage(inheritedEntityIds, rawPath, value) {
         [rawPath]: entityId,
     };
 }
-function wrapWithProvenance(value, pathTokens, inheritedEntityIds = {}) {
+function wrapWithProvenance(value, pathTokens, inheritedEntityIds = {}, options = {}) {
     if (!provenanceEnabled)
         return value;
     if (!value || typeof value !== "object")
@@ -360,6 +427,7 @@ function wrapWithProvenance(value, pathTokens, inheritedEntityIds = {}) {
     const proxy = new Proxy(objectValue, {
         get(target, property, receiver) {
             if (property === "toJSON" &&
+                options.transportSerializable !== false &&
                 isCanvasTransportEnabled() &&
                 isRootRawPath(pathKey)) {
                 return () => wrapCanvasTransportRoot(target, pathKey);
@@ -371,7 +439,7 @@ function wrapWithProvenance(value, pathTokens, inheritedEntityIds = {}) {
             if (!trackedToken)
                 return result;
             const nextPath = [...pathTokens, trackedToken];
-            const wrappedResult = wrapWithProvenance(result, nextPath, buildEntityLineage(currentEntityIds, nextPath.join("."), result));
+            const wrappedResult = wrapWithProvenance(result, nextPath, buildEntityLineage(currentEntityIds, nextPath.join("."), result), options);
             recordPath(nextPath);
             recordCapture(nextPath, wrappedResult);
             return wrappedResult;
@@ -409,7 +477,9 @@ function attachCms0ProvenanceRoot(value, rootId, options) {
     const normalizedRoot = typeof rootId === "string" ? rootId.trim() : "";
     if (!normalizedRoot)
         return value;
-    const wrapped = wrapWithProvenance(value, [normalizedRoot]);
+    const wrapped = wrapWithProvenance(value, [normalizedRoot], {}, {
+        transportSerializable: options?.transportSerializable,
+    });
     if (options?.registerLiveRoot !== false &&
         wrapped &&
         typeof wrapped === "object") {

package/dist/cjs/schema-descriptors.cjs

@@ -1,5 +1,268 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.schemaDescriptor = void 0;
-var schema_descriptor_1 = require("@cms0/cms0/generated/schema-descriptor");
-Object.defineProperty(exports, "schemaDescriptor", { enumerable: true, get: function () { return schema_descriptor_1.schemaDescriptor; } });
+exports.readLocalSchemaDescriptor = readLocalSchemaDescriptor;
+exports.resolveBrowserSchemaDescriptor = resolveBrowserSchemaDescriptor;
+exports.getActiveSchemaDescriptor = getActiveSchemaDescriptor;
+exports.syncActiveSchemaDescriptorGlobals = syncActiveSchemaDescriptorGlobals;
+const schema_descriptor_1 = require("@cms0/cms0/generated/schema-descriptor");
+const descriptor_sidecar_js_1 = require("./descriptor-sidecar.cjs");
+const LOCAL_DESCRIPTOR_RELATIVE_SEGMENTS = [
+    ".cms0",
+    "generated",
+    "schema-descriptor.json",
+];
+let cachedLocalDescriptor = null;
+const browserDescriptorPromiseCache = new Map();
+exports.schemaDescriptor = schema_descriptor_1.schemaDescriptor;
+function setSchemaDescriptorGlobals(descriptor) {
+    const globals = globalThis;
+    globals.__CMS0_SCHEMA_DESCRIPTOR__ = descriptor;
+    globals.__CMS0_CANVAS_SCHEMA_DESCRIPTOR__ = descriptor;
+    return descriptor;
+}
+function createMissingBrowserDescriptorError() {
+    return new Error("cms0: no browser schema descriptor is active. Start the cms0 sidecar so the browser can load the descriptor generated from .cms0. Bundled package descriptors are not used at runtime.");
+}
+function createMissingLocalDescriptorError() {
+    return new Error("cms0: no local schema descriptor was found. Expected .cms0/generated/schema-descriptor.json near the current project root. Run cms0 dev or cms0 build before calling cms0().");
+}
+function getBuiltinModule(specifier) {
+    const runtimeProcess = globalThis.process;
+    if (typeof runtimeProcess?.getBuiltinModule === "function") {
+        try {
+            return runtimeProcess.getBuiltinModule(specifier);
+        }
+        catch {
+            // Ignore missing builtins and fall through.
+        }
+    }
+    try {
+        const runtimeRequire = Function("try { return require; } catch { return undefined; }")();
+        if (runtimeRequire) {
+            return runtimeRequire(specifier);
+        }
+    }
+    catch {
+        // Ignore runtime require failures outside Node/CommonJS.
+    }
+    return null;
+}
+function getNodeFs() {
+    return (getBuiltinModule("node:fs") ??
+        getBuiltinModule("fs"));
+}
+function getNodePath() {
+    return (getBuiltinModule("node:path") ??
+        getBuiltinModule("path"));
+}
+function getNodeUrl() {
+    return (getBuiltinModule("node:url") ??
+        getBuiltinModule("url"));
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isFullDescriptor(value) {
+    return isRecord(value) && isRecord(value.models) && isRecord(value.roots);
+}
+function dedupePaths(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        const normalized = value.trim();
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        result.push(normalized);
+    }
+    return result;
+}
+function parseStackFramePath(line) {
+    const urlModule = getNodeUrl();
+    const directMatch = line.match(/\((file:\/\/[^)]+|\/[^)]+):\d+:\d+\)$/) ??
+        line.match(/at (file:\/\/\S+|\/\S+):\d+:\d+$/);
+    const rawPath = directMatch?.[1];
+    if (!rawPath)
+        return null;
+    if (rawPath.startsWith("file://")) {
+        if (urlModule) {
+            try {
+                return urlModule.fileURLToPath(rawPath);
+            }
+            catch {
+                return null;
+            }
+        }
+        try {
+            return decodeURIComponent(new URL(rawPath).pathname);
+        }
+        catch {
+            return null;
+        }
+    }
+    return rawPath;
+}
+function resolveSchemaDescriptorSearchRoots() {
+    const pathModule = getNodePath();
+    if (!pathModule || typeof process === "undefined") {
+        return [];
+    }
+    const roots = [];
+    const projectRootOverride = process.env.CMS0_PROJECT_ROOT;
+    if (typeof projectRootOverride === "string" && projectRootOverride.trim()) {
+        roots.push(pathModule.resolve(projectRootOverride));
+    }
+    const descriptorPathOverride = process.env.CMS0_SCHEMA_DESCRIPTOR_PATH;
+    if (typeof descriptorPathOverride === "string" && descriptorPathOverride.trim()) {
+        roots.push(pathModule.dirname(pathModule.resolve(descriptorPathOverride)));
+    }
+    const stack = new Error().stack ?? "";
+    for (const line of stack.split("\n").slice(1)) {
+        const filePath = parseStackFramePath(line);
+        if (!filePath)
+            continue;
+        roots.push(pathModule.dirname(pathModule.resolve(filePath)));
+    }
+    if (typeof process.cwd === "function") {
+        roots.push(pathModule.resolve(process.cwd()));
+    }
+    return dedupePaths(roots);
+}
+function resolveLocalSchemaDescriptorPath(searchRoots) {
+    const fs = getNodeFs();
+    const pathModule = getNodePath();
+    if (!fs || !pathModule) {
+        return null;
+    }
+    const directOverride = process.env.CMS0_SCHEMA_DESCRIPTOR_PATH;
+    if (typeof directOverride === "string" && directOverride.trim()) {
+        const resolvedDirectOverride = pathModule.resolve(directOverride);
+        if (fs.existsSync(resolvedDirectOverride)) {
+            return resolvedDirectOverride;
+        }
+    }
+    for (const root of searchRoots) {
+        let current = pathModule.resolve(root);
+        while (true) {
+            const candidate = pathModule.join(current, ...LOCAL_DESCRIPTOR_RELATIVE_SEGMENTS);
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+            const parent = pathModule.dirname(current);
+            if (parent === current)
+                break;
+            current = parent;
+        }
+    }
+    return null;
+}
+function readLocalSchemaDescriptor(searchRoots = resolveSchemaDescriptorSearchRoots()) {
+    const fs = getNodeFs();
+    if (!fs) {
+        return null;
+    }
+    const descriptorPath = resolveLocalSchemaDescriptorPath(searchRoots);
+    if (!descriptorPath) {
+        return null;
+    }
+    try {
+        const stat = fs.statSync(descriptorPath);
+        if (cachedLocalDescriptor &&
+            cachedLocalDescriptor.path === descriptorPath &&
+            cachedLocalDescriptor.mtimeMs === stat.mtimeMs) {
+            return cachedLocalDescriptor.descriptor;
+        }
+        const parsed = JSON.parse(fs.readFileSync(descriptorPath, "utf8"));
+        if (!isFullDescriptor(parsed)) {
+            return null;
+        }
+        cachedLocalDescriptor = {
+            descriptor: parsed,
+            mtimeMs: stat.mtimeMs,
+            path: descriptorPath,
+        };
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function readGlobalSchemaDescriptor() {
+    const globals = globalThis;
+    const activeDescriptor = globals.__CMS0_CANVAS_SCHEMA_DESCRIPTOR__ ?? globals.__CMS0_SCHEMA_DESCRIPTOR__;
+    return isFullDescriptor(activeDescriptor) ? activeDescriptor : null;
+}
+function isBundledFallbackDescriptor(descriptor) {
+    return (isRecord(descriptor.metadata) &&
+        descriptor.metadata.__cms0Fallback === true);
+}
+function readBundledBrowserDescriptor() {
+    const descriptor = schema_descriptor_1.schemaDescriptor;
+    return isBundledFallbackDescriptor(descriptor) ? null : descriptor;
+}
+function createBrowserDescriptorFetchError(sidecarUrl, reason) {
+    const details = reason ? ` ${reason}` : "";
+    return new Error(`cms0: failed to load the browser schema descriptor from ${sidecarUrl}.${details} Start the cms0 sidecar before calling cms0() in the browser.`);
+}
+async function resolveBrowserSchemaDescriptor(baseUrl, apiKey) {
+    const injectedDescriptor = readGlobalSchemaDescriptor();
+    if (injectedDescriptor) {
+        return setSchemaDescriptorGlobals(injectedDescriptor);
+    }
+    const bundledDescriptor = readBundledBrowserDescriptor();
+    if (bundledDescriptor) {
+        return setSchemaDescriptorGlobals(bundledDescriptor);
+    }
+    const sidecarUrl = (0, descriptor_sidecar_js_1.getCms0DescriptorSidecarUrl)(baseUrl, apiKey);
+    const cachedPromise = browserDescriptorPromiseCache.get(sidecarUrl);
+    if (cachedPromise) {
+        return cachedPromise;
+    }
+    const descriptorPromise = (async () => {
+        try {
+            const response = await fetch(sidecarUrl, {
+                headers: {
+                    accept: "application/json",
+                },
+            });
+            if (!response.ok) {
+                throw createBrowserDescriptorFetchError(sidecarUrl, `HTTP ${response.status}`);
+            }
+            const parsed = await response.json();
+            if (!isFullDescriptor(parsed)) {
+                throw createBrowserDescriptorFetchError(sidecarUrl, "Received an invalid descriptor payload.");
+            }
+            return setSchemaDescriptorGlobals(parsed);
+        }
+        catch (error) {
+            browserDescriptorPromiseCache.delete(sidecarUrl);
+            if (error instanceof Error) {
+                throw createBrowserDescriptorFetchError(sidecarUrl, error.message);
+            }
+            throw createBrowserDescriptorFetchError(sidecarUrl);
+        }
+    })();
+    browserDescriptorPromiseCache.set(sidecarUrl, descriptorPromise);
+    return descriptorPromise;
+}
+function getActiveSchemaDescriptor() {
+    if (typeof window !== "undefined") {
+        const injectedDescriptor = readGlobalSchemaDescriptor();
+        if (!injectedDescriptor) {
+            throw createMissingBrowserDescriptorError();
+        }
+        return setSchemaDescriptorGlobals(injectedDescriptor);
+    }
+    return setSchemaDescriptorGlobals(resolveActiveSchemaDescriptor());
+}
+function resolveActiveSchemaDescriptor() {
+    const localDescriptor = readLocalSchemaDescriptor();
+    if (!localDescriptor) {
+        throw createMissingLocalDescriptorError();
+    }
+    return localDescriptor;
+}
+function syncActiveSchemaDescriptorGlobals() {
+    return setSchemaDescriptorGlobals(getActiveSchemaDescriptor());
+}

package/dist/esm/descriptor-sidecar.js

@@ -0,0 +1,16 @@
+function hashCms0SidecarSeed(seed) {
+    let hash = 5381;
+    for (let index = 0; index < seed.length; index += 1) {
+        hash = ((hash << 5) + hash + seed.charCodeAt(index)) >>> 0;
+    }
+    return hash >>> 0;
+}
+function getCms0DescriptorSidecarPort(baseUrl, apiKey) {
+    const seed = `${baseUrl?.trim() ?? ""}|${apiKey?.trim() ?? ""}`;
+    return 43129 + (hashCms0SidecarSeed(seed) % 1000);
+}
+function getCms0DescriptorSidecarUrl(baseUrl, apiKey) {
+    const port = getCms0DescriptorSidecarPort(baseUrl, apiKey);
+    return `http://127.0.0.1:${port}/schema-descriptor`;
+}
+export { getCms0DescriptorSidecarPort, getCms0DescriptorSidecarUrl, hashCms0SidecarSeed, };

package/dist/esm/generated/schema-descriptor.js

@@ -2,4 +2,7 @@
 export const schemaDescriptor = {
     models: {},
     roots: {},
+    metadata: {
+        __cms0Fallback: true,
+    },
 };