@cms0/cms0 0.2.17 → 0.2.19

package/dist/cjs/descriptor-sidecar.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCms0DescriptorSidecarPort = getCms0DescriptorSidecarPort;
+exports.getCms0DescriptorSidecarUrl = getCms0DescriptorSidecarUrl;
+exports.hashCms0SidecarSeed = hashCms0SidecarSeed;
+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`;
+}

package/dist/cjs/generated/schema-descriptor.cjs

@@ -5,4 +5,7 @@ exports.schemaDescriptor = void 0;
 exports.schemaDescriptor = {
     models: {},
     roots: {},
+    metadata: {
+        __cms0Fallback: true,
+    },
 };

package/dist/cjs/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toTwitter = exports.toOpenGraph = exports.toNextMetadata = exports.resolveLocalized = exports.unwrapCms0CanvasTransportValue = exports.restoreCms0CanvasTransportMetadata = exports.readCms0ProvenanceValueMeta = exports.readCms0LiveRoots = exports.registerCms0CollectionItemIdentity = exports.registerCms0LiveRoot = exports.readCms0CollectionItemIdentity = exports.readCms0CanvasTransportCollectionItemId = exports.enableCms0ProvenanceTracking = exports.captureCms0Provenance = exports.attachCms0ProvenanceRoot = exports.activateCms0CanvasTransport = void 0;
+exports.toTwitter = exports.toOpenGraph = exports.toNextMetadata = exports.resolveLocalized = exports.unwrapCms0CanvasTransportValue = exports.restoreCms0CanvasTransportMetadata = exports.readCms0ProvenanceValueMeta = exports.readCms0LiveRoots = exports.registerCms0CollectionItemIdentity = exports.registerCms0LiveRoot = exports.readCms0CollectionItemIdentity = exports.readCms0CanvasTransportCollectionItemId = exports.enableCms0ProvenanceTracking = exports.dehydrateCms0CanvasVisibleValue = exports.dehydrateCms0CanvasTransportValue = exports.captureCms0Provenance = exports.attachCms0ProvenanceRoot = exports.activateCms0CanvasTransport = void 0;
 exports.createCmsClient = createCmsClient;
 exports.cms0 = cms0;
 const provenance_1 = require("@cms0/cms0/provenance");
@@ -552,7 +552,7 @@ async function readCanvasModelRefCollectionIdentities(path, descriptor, context)
     cache.set(cacheKey, pending);
     return pending;
 }
-async function normalizeModelRef(modelName, id, context, trail, isCollectionItem, inlineValue) {
+async function normalizeModelRef(modelName, id, context, trail, isCollectionItem, inlineValue, projectionPathTokens = []) {
     if (!id)
         return null;
     if (!context.options.resolveModelRefs)
@@ -580,14 +580,29 @@ async function normalizeModelRef(modelName, id, context, trail, isCollectionItem
     const nextTrail = new Set(trail);
     nextTrail.add(nodeKey);
     const promise = (async () => {
+        const modelPath = `models/${modelName}/${id}`;
+        const resolvedModelPath = `_resolved/models/${encodeURIComponent(modelName)}/${encodeURIComponent(id)}`;
         const rawModel = inlineModel ??
-            (await context.requestJson(`models/${modelName}/${id}`, {
-                query: {
+            (await (async () => {
+                const query = {
                     raw: 1,
                     ...(context.options.locale ? { locale: context.options.locale } : {}),
-                },
-            }));
-        return normalizeField(modelDescriptor, `models/${modelName}/${encodeURIComponent(id)}`, rawModel, context, nextTrail, isCollectionItem);
+                };
+                try {
+                    return await context.requestJson(resolvedModelPath, {
+                        query: {
+                            ...query,
+                            resolveModelRefs: 1,
+                        },
+                    });
+                }
+                catch {
+                    return context.requestJson(modelPath, {
+                        query,
+                    });
+                }
+            })());
+        return normalizeField(modelDescriptor, `models/${modelName}/${encodeURIComponent(id)}`, rawModel, context, nextTrail, isCollectionItem, projectionPathTokens);
     })();
     context.modelCache.set(nodeKey, promise);
     context.sharedModelInflightCache.set(nodeKey, promise);
@@ -607,12 +622,16 @@ function missingModelRefValue(descriptor) {
         return undefined;
     return null;
 }
-async function normalizeObjectField(descriptor, path, raw, context, trail, isCollectionItem) {
+async function normalizeObjectField(descriptor, path, raw, context, trail, isCollectionItem, projectionPathTokens = []) {
     const source = raw && typeof raw === "object" ? raw : {};
     const output = {};
     for (const [propertyName, propertyDescriptor] of Object.entries(descriptor.properties)) {
+        const childProjectionPathTokens = [...projectionPathTokens, propertyName];
+        if (!shouldTraverseProjectionPath(childProjectionPathTokens, context.options.includeProjectionPaths, context.options.excludeProjectionPaths)) {
+            continue;
+        }
         if (isScalarDescriptor(propertyDescriptor)) {
-            output[propertyName] = await normalizeField(propertyDescriptor, `${path}/${propertyName}`, source[propertyName], context, trail, false);
+            output[propertyName] = await normalizeField(propertyDescriptor, `${path}/${propertyName}`, source[propertyName], context, trail, false, childProjectionPathTokens);
             continue;
         }
         if (isModelRefDescriptor(propertyDescriptor)) {
@@ -636,7 +655,7 @@ async function normalizeObjectField(descriptor, path, raw, context, trail, isCol
                 }
                 continue;
             }
-            output[propertyName] = await normalizeModelRef(propertyDescriptor.model, refId, context, trail, false, inlineValue);
+            output[propertyName] = await normalizeModelRef(propertyDescriptor.model, refId, context, trail, false, inlineValue, childProjectionPathTokens);
             continue;
         }
         if (isArrayDescriptor(propertyDescriptor)) {
@@ -654,7 +673,7 @@ async function normalizeObjectField(descriptor, path, raw, context, trail, isCol
                         ...(context.options.locale ? { locale: context.options.locale } : {}),
                     },
                 });
-            const normalizedChild = await normalizeArrayField(propertyDescriptor, childPath, childRaw, context, trail, inlineChildRaw !== undefined);
+            const normalizedChild = await normalizeArrayField(propertyDescriptor, childPath, childRaw, context, trail, inlineChildRaw !== undefined, childProjectionPathTokens);
             output[propertyName] = coerceCustomTypeValue(propertyDescriptor, normalizedChild, {
                 locale: context.options.locale,
                 defaultLocale: context.options.defaultLocale,
@@ -677,7 +696,7 @@ async function normalizeObjectField(descriptor, path, raw, context, trail, isCol
                         ...(context.options.locale ? { locale: context.options.locale } : {}),
                     },
                 });
-            const normalizedChild = await normalizeObjectField(propertyDescriptor, childPath, childRaw, context, trail, false);
+            const normalizedChild = await normalizeObjectField(propertyDescriptor, childPath, childRaw, context, trail, false, childProjectionPathTokens);
             output[propertyName] = coerceCustomTypeValue(propertyDescriptor, normalizedChild, {
                 locale: context.options.locale,
                 defaultLocale: context.options.defaultLocale,
@@ -697,12 +716,12 @@ async function normalizeObjectField(descriptor, path, raw, context, trail, isCol
     }
     return maybeAttachAssetUrl(output, context.options.assetUrlBuilder);
 }
-async function normalizeArrayField(descriptor, path, raw, context, trail, inlineResolvedItems = false) {
+async function normalizeArrayField(descriptor, path, raw, context, trail, inlineResolvedItems = false, projectionPathTokens = []) {
     const envelope = ensureCollectionEnvelope(raw, path);
     const itemDescriptor = descriptor.items;
     if (isScalarDescriptor(itemDescriptor)) {
         return mapWithConcurrency(envelope.items, context.options.modelNormalizationConcurrency, async (row) => {
-            const normalizedValue = await normalizeField(itemDescriptor, path, row, context, trail, true);
+            const normalizedValue = await normalizeField(itemDescriptor, path, row, context, trail, true, projectionPathTokens);
             if (context.options.includeIdMode !== "all") {
                 return normalizedValue;
             }
@@ -725,7 +744,7 @@ async function normalizeArrayField(descriptor, path, raw, context, trail, inline
             const refId = extractModelRefId(row, itemDescriptor.model, {
                 allowObjectIdFallback: false,
             }) ?? (inlineModel ? extractId(inlineModel) : null);
-            const normalized = await normalizeModelRef(itemDescriptor.model, refId, context, trail, true, row);
+            const normalized = await normalizeModelRef(itemDescriptor.model, refId, context, trail, true, row, projectionPathTokens);
             const collectionItemId = collectionIdentities?.[index]?.relationId ??
                 (inlineResolvedItems ? null : extractId(row));
             if (!collectionItemId ||
@@ -748,12 +767,12 @@ async function normalizeArrayField(descriptor, path, raw, context, trail, inline
             const rowPath = rowId
                 ? `${path}/${encodeURIComponent(rowId)}`
                 : path;
-            return normalizeObjectField(itemDescriptor, rowPath, row, context, trail, true);
+            return normalizeObjectField(itemDescriptor, rowPath, row, context, trail, true, projectionPathTokens);
         });
     }
     return envelope.items;
 }
-async function normalizeInlineField(descriptor, raw, context, trail, isCollectionItem) {
+async function normalizeInlineField(descriptor, raw, context, trail, isCollectionItem, projectionPathTokens = []) {
     if (isPrimitiveDescriptor(descriptor)) {
         return coerceCustomTypeValue(descriptor, raw, {
             locale: context.options.locale,
@@ -771,7 +790,7 @@ async function normalizeInlineField(descriptor, raw, context, trail, isCollectio
         if (!decoded) {
             return null;
         }
-        return normalizeInlineField(decoded.branchDescriptor, decoded.branchValue, context, trail, isCollectionItem);
+        return normalizeInlineField(decoded.branchDescriptor, decoded.branchValue, context, trail, isCollectionItem, projectionPathTokens);
     }
     if (isModelRefDescriptor(descriptor)) {
         const refId = extractModelRefId(raw, descriptor.model, {
@@ -780,11 +799,11 @@ async function normalizeInlineField(descriptor, raw, context, trail, isCollectio
         if (!refId) {
             return missingModelRefValue(descriptor);
         }
-        return normalizeModelRef(descriptor.model, refId, context, trail, isCollectionItem, raw);
+        return normalizeModelRef(descriptor.model, refId, context, trail, isCollectionItem, raw, projectionPathTokens);
     }
     if (isArrayDescriptor(descriptor)) {
         const source = Array.isArray(raw) ? raw : [];
-        const normalized = await mapWithConcurrency(source, context.options.modelNormalizationConcurrency, async (entry) => normalizeInlineField(descriptor.items, entry, context, trail, true));
+        const normalized = await mapWithConcurrency(source, context.options.modelNormalizationConcurrency, async (entry) => normalizeInlineField(descriptor.items, entry, context, trail, true, projectionPathTokens));
         return coerceCustomTypeValue(descriptor, normalized, {
             locale: context.options.locale,
             defaultLocale: context.options.defaultLocale,
@@ -797,7 +816,7 @@ async function normalizeInlineField(descriptor, raw, context, trail, isCollectio
             : {};
         const output = {};
         for (const [propertyName, propertyDescriptor] of Object.entries(descriptor.properties)) {
-            output[propertyName] = await normalizeInlineField(propertyDescriptor, source[propertyName], context, trail, false);
+            output[propertyName] = await normalizeInlineField(propertyDescriptor, source[propertyName], context, trail, false, [...projectionPathTokens, propertyName]);
         }
         return coerceCustomTypeValue(descriptor, output, {
             locale: context.options.locale,
@@ -807,7 +826,7 @@ async function normalizeInlineField(descriptor, raw, context, trail, isCollectio
     }
     return raw;
 }
-async function normalizeField(descriptor, path, raw, context, trail, isCollectionItem) {
+async function normalizeField(descriptor, path, raw, context, trail, isCollectionItem, projectionPathTokens = []) {
     if (isPrimitiveDescriptor(descriptor)) {
         const value = raw && typeof raw === "object" && "value" in raw
             ? raw.value
@@ -839,7 +858,7 @@ async function normalizeField(descriptor, path, raw, context, trail, isCollectio
         if (!decoded) {
             return null;
         }
-        let normalized = await normalizeInlineField(decoded.branchDescriptor, decoded.branchValue, context, trail, isCollectionItem);
+        let normalized = await normalizeInlineField(decoded.branchDescriptor, decoded.branchValue, context, trail, isCollectionItem, projectionPathTokens);
         if (shouldIncludeObjectId(context.options.includeIdMode, isCollectionItem)) {
             const id = decoded.rowId ?? extractId(raw);
             normalized = attachIdForScalarDescriptor(descriptor, normalized, id);
@@ -860,7 +879,7 @@ async function normalizeField(descriptor, path, raw, context, trail, isCollectio
         return normalizeModelRef(descriptor.model, refId, context, trail, isCollectionItem, raw);
     }
     if (isArrayDescriptor(descriptor)) {
-        const normalized = await normalizeArrayField(descriptor, path, raw, context, trail);
+        const normalized = await normalizeArrayField(descriptor, path, raw, context, trail, false, projectionPathTokens);
         return coerceCustomTypeValue(descriptor, normalized, {
             locale: context.options.locale,
             defaultLocale: context.options.defaultLocale,
@@ -868,7 +887,7 @@ async function normalizeField(descriptor, path, raw, context, trail, isCollectio
         });
     }
     if (isObjectDescriptor(descriptor)) {
-        const normalized = await normalizeObjectField(descriptor, path, raw, context, trail, isCollectionItem);
+        const normalized = await normalizeObjectField(descriptor, path, raw, context, trail, isCollectionItem, projectionPathTokens);
         return coerceCustomTypeValue(descriptor, normalized, {
             locale: context.options.locale,
             defaultLocale: context.options.defaultLocale,
@@ -983,6 +1002,22 @@ function normalizeProjectionPaths(input) {
     }
     return Array.from(unique).map((path) => path.split("."));
 }
+function isProjectionPathPrefix(prefix, value) {
+    if (prefix.length > value.length)
+        return false;
+    return prefix.every((token, index) => value[index] === token);
+}
+function shouldTraverseProjectionPath(childTokens, includePaths, excludePaths) {
+    if (includePaths.length > 0 &&
+        !includePaths.some((pathTokens) => isProjectionPathPrefix(pathTokens, childTokens) ||
+            isProjectionPathPrefix(childTokens, pathTokens))) {
+        return false;
+    }
+    if (excludePaths.some((pathTokens) => isProjectionPathPrefix(pathTokens, childTokens))) {
+        return false;
+    }
+    return true;
+}
 function mergeProjectedValue(existing, incoming) {
     if (incoming === undefined)
         return existing;
@@ -1143,6 +1178,9 @@ async function runResource(resource, descriptor, baseUrl, apiKey, defaultLocale,
     const responseMode = options?.response ?? "normalized";
     const includeIdMode = resolveIncludeIdMode(options?.includeId, globalIncludeId);
     const resolveModelRefs = options?.resolveModelRefs !== false;
+    const includeProjectionPaths = normalizeProjectionPaths(options?.fields);
+    const excludeProjectionPaths = normalizeProjectionPaths(options?.exclude);
+    const shouldValidateFullResult = includeProjectionPaths.length === 0 && excludeProjectionPaths.length === 0;
     const requestedLocale = options?.locale ??
         (typeof options?.query?.locale === "string"
             ? options.query.locale
@@ -1235,6 +1273,8 @@ async function runResource(resource, descriptor, baseUrl, apiKey, defaultLocale,
             defaultLocale,
             assetUrlBuilder,
             modelNormalizationConcurrency: DEFAULT_MODEL_NORMALIZATION_CONCURRENCY,
+            includeProjectionPaths,
+            excludeProjectionPaths,
         },
     };
     if (resource.isCollection && !byId) {
@@ -1250,17 +1290,23 @@ async function runResource(resource, descriptor, baseUrl, apiKey, defaultLocale,
         const normalizedItems = await normalizeArrayField(descriptorForCollection, resource.path, envelope, context, new Set());
         if (responseMode === "envelope") {
             const projectedItems = applyFieldProjection(normalizedItems, options?.fields, options?.exclude);
-            validateResult(resource, normalizedItems, descriptor, includeIdMode, zodSchemas, modelZodSchemas);
+            if (shouldValidateFullResult) {
+                validateResult(resource, normalizedItems, descriptor, includeIdMode, zodSchemas, modelZodSchemas);
+            }
             return {
                 items: attachResourceProvenanceWithOptions(resource, Array.isArray(projectedItems) ? projectedItems : normalizedItems, provenanceOptions),
                 total: envelope.total,
             };
         }
-        validateResult(resource, normalizedItems, descriptor, includeIdMode, zodSchemas, modelZodSchemas);
+        if (shouldValidateFullResult) {
+            validateResult(resource, normalizedItems, descriptor, includeIdMode, zodSchemas, modelZodSchemas);
+        }
         return attachResourceProvenanceWithOptions(resource, normalizedItems, provenanceOptions);
     }
     const normalized = await normalizeField(resource.descriptor, normalizePath, rawData, context, new Set(), false);
-    validateResult(resource, normalized, descriptor, includeIdMode, zodSchemas, modelZodSchemas);
+    if (shouldValidateFullResult) {
+        validateResult(resource, normalized, descriptor, includeIdMode, zodSchemas, modelZodSchemas);
+    }
     return attachResourceProvenanceWithOptions(resource, applyFieldProjection(normalized, options?.fields, options?.exclude), provenanceOptions);
 }
 function createCmsClient(descriptor, config) {
@@ -1345,12 +1391,72 @@ function createCmsClient(descriptor, config) {
     return rootProxy;
 }
 function cms0(config) {
-    return createCmsClient(schema_descriptors_1.schemaDescriptor, config);
+    if (typeof window !== "undefined") {
+        return createLazyBrowserCmsClient(config);
+    }
+    return createCmsClient((0, schema_descriptors_1.getActiveSchemaDescriptor)(), config);
+}
+function createLazyBrowserCmsClient(config) {
+    let clientPromise = null;
+    const resolveClient = async () => {
+        if (!clientPromise) {
+            clientPromise = (0, schema_descriptors_1.resolveBrowserSchemaDescriptor)(config.apiConfig?.baseUrl, config.apiConfig?.key).then((descriptor) => createCmsClient(descriptor, config));
+        }
+        return clientPromise;
+    };
+    const buildModelAccessor = (property) => {
+        const accessor = (async (options) => {
+            const client = await resolveClient();
+            return client.models[property](options);
+        });
+        accessor.byId = async (id, options) => {
+            const client = await resolveClient();
+            return client.models[property].byId(id, options);
+        };
+        return accessor;
+    };
+    const modelsProxy = new Proxy({}, {
+        get(_target, property) {
+            if (typeof property !== "string")
+                return undefined;
+            if (property === "then")
+                return undefined;
+            return buildModelAccessor(property);
+        },
+    });
+    const clientMeta = {
+        locales: config.locales ?? [],
+        defaultLocale: config.defaultLocale,
+        includeIdDefault: !!config.includeId,
+    };
+    const rootProxyTarget = {
+        models: modelsProxy,
+        meta: clientMeta,
+    };
+    const rootProxy = new Proxy(rootProxyTarget, {
+        get(target, property, receiver) {
+            if (typeof property !== "string") {
+                return Reflect.get(target, property, receiver);
+            }
+            if (property === "then")
+                return undefined;
+            if (Reflect.has(target, property)) {
+                return Reflect.get(target, property, receiver);
+            }
+            return async (options) => {
+                const client = await resolveClient();
+                return client[property](options);
+            };
+        },
+    });
+    return rootProxy;
 }
 var provenance_js_1 = require("./provenance.cjs");
 Object.defineProperty(exports, "activateCms0CanvasTransport", { enumerable: true, get: function () { return provenance_js_1.activateCms0CanvasTransport; } });
 Object.defineProperty(exports, "attachCms0ProvenanceRoot", { enumerable: true, get: function () { return provenance_js_1.attachCms0ProvenanceRoot; } });
 Object.defineProperty(exports, "captureCms0Provenance", { enumerable: true, get: function () { return provenance_js_1.captureCms0Provenance; } });
+Object.defineProperty(exports, "dehydrateCms0CanvasTransportValue", { enumerable: true, get: function () { return provenance_js_1.dehydrateCms0CanvasTransportValue; } });
+Object.defineProperty(exports, "dehydrateCms0CanvasVisibleValue", { enumerable: true, get: function () { return provenance_js_1.dehydrateCms0CanvasVisibleValue; } });
 Object.defineProperty(exports, "enableCms0ProvenanceTracking", { enumerable: true, get: function () { return provenance_js_1.enableCms0ProvenanceTracking; } });
 Object.defineProperty(exports, "readCms0CanvasTransportCollectionItemId", { enumerable: true, get: function () { return provenance_js_1.readCms0CanvasTransportCollectionItemId; } });
 Object.defineProperty(exports, "readCms0CollectionItemIdentity", { enumerable: true, get: function () { return provenance_js_1.readCms0CollectionItemIdentity; } });

package/dist/cjs/libs/cli/browser-sidecar.cjs

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startBrowserDescriptorSidecar = startBrowserDescriptorSidecar;
+const node_http_1 = __importDefault(require("node:http"));
+const descriptor_sidecar_js_1 = require("../../descriptor-sidecar.cjs");
+function startBrowserDescriptorSidecar(resolved, initialDescriptor) {
+    const port = (0, descriptor_sidecar_js_1.getCms0DescriptorSidecarPort)(resolved.apiBaseUrl, resolved.apiKey);
+    let currentDescriptor = initialDescriptor;
+    const server = node_http_1.default.createServer((request, response) => {
+        const requestUrl = new URL(request.url ?? "/", `http://127.0.0.1:${port}`);
+        response.setHeader("Access-Control-Allow-Origin", "*");
+        response.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+        response.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        if (request.method === "OPTIONS") {
+            response.writeHead(204);
+            response.end();
+            return;
+        }
+        if (request.method !== "GET" || requestUrl.pathname !== "/schema-descriptor") {
+            response.writeHead(404, { "content-type": "application/json; charset=utf-8" });
+            response.end(JSON.stringify({ error: "Not found" }));
+            return;
+        }
+        response.writeHead(200, {
+            "content-type": "application/json; charset=utf-8",
+            "cache-control": "no-store",
+        });
+        response.end(JSON.stringify(currentDescriptor));
+    });
+    return new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, "127.0.0.1", () => {
+            server.off("error", reject);
+            console.log(`cms0: browser descriptor sidecar listening on http://127.0.0.1:${port}/schema-descriptor`);
+            resolve({
+                updateDescriptor(descriptor) {
+                    currentDescriptor = descriptor;
+                },
+                close() {
+                    return new Promise((closeResolve, closeReject) => {
+                        server.close((error) => {
+                            if (error) {
+                                closeReject(error);
+                                return;
+                            }
+                            closeResolve();
+                        });
+                    });
+                },
+            });
+        });
+    });
+}

package/dist/cjs/libs/cli/build.cjs

@@ -5,9 +5,9 @@ exports.buildOnce = buildOnce;
 const descriptor_builder_alt_js_1 = require("./descriptor-builder-alt.cjs");
 const publisher_js_1 = require("./publisher.cjs");
 const descriptor_writer_js_1 = require("./descriptor-writer.cjs");
-function buildOnce(resolved) {
+function buildOnce(resolved, browserTarget = "sidecar") {
     const descriptor = (0, descriptor_builder_alt_js_1.buildDescriptorAlt)(resolved);
-    (0, descriptor_writer_js_1.writeDescriptorFiles)(descriptor);
+    (0, descriptor_writer_js_1.writeDescriptorFiles)(resolved, descriptor, browserTarget);
     (0, publisher_js_1.publishDescriptor)(resolved, descriptor);
     return descriptor;
 }

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

@@ -4,6 +4,7 @@ exports.runFromCli = runFromCli;
 // CLI entry point: parse arguments, load config, and trigger build/watch modes.
 const url_1 = require("url");
 const build_js_1 = require("./build.cjs");
+const browser_sidecar_js_1 = require("./browser-sidecar.cjs");
 const config_loader_js_1 = require("./config-loader.cjs");
 const watcher_js_1 = require("./watcher.cjs");
 async function runFromCli() {
@@ -29,14 +30,18 @@ async function runFromCli() {
     const resolved = (0, config_loader_js_1.resolvePaths)(loaded.path, loaded.config);
     console.log("resolved: ", resolved);
     if (mode === "watch") {
-        (0, watcher_js_1.startWatcher)(resolved);
+        const descriptor = (0, build_js_1.buildOnce)(resolved, "sidecar");
+        const sidecar = await (0, browser_sidecar_js_1.startBrowserDescriptorSidecar)(resolved, descriptor);
+        (0, watcher_js_1.startWatcher)(resolved, (nextDescriptor) => sidecar.updateDescriptor(nextDescriptor), "sidecar", false);
         return;
     }
     if (mode === "dev") {
-        (0, watcher_js_1.startWatcher)(resolved);
+        const descriptor = (0, build_js_1.buildOnce)(resolved, "sidecar");
+        const sidecar = await (0, browser_sidecar_js_1.startBrowserDescriptorSidecar)(resolved, descriptor);
+        (0, watcher_js_1.startWatcher)(resolved, (nextDescriptor) => sidecar.updateDescriptor(nextDescriptor), "sidecar", false);
         return;
     }
-    (0, build_js_1.buildOnce)(resolved);
+    (0, build_js_1.buildOnce)(resolved, "bundle");
 }
 // ESM/CJS-safe main check without import.meta syntax in the source so CJS builds succeed.
 const isDirectRun = (() => {

package/dist/cjs/libs/cli/config-loader.cjs

@@ -114,38 +114,20 @@ async function loadUserConfig(configPath) {
         return { path: resolvedPath, config: JSON.parse(json) };
     }
     if (ext === ".ts" || ext === ".mts" || ext === ".cts" || ext === ".tsx") {
-        // If the enclosing package is ESM, use dynamic import instead of require.
         const pkgJsonPath = findNearestPackageJson(resolvedPath);
         const pkgType = pkgJsonPath ? readPackageType(pkgJsonPath) : undefined;
         const isEsmPkg = pkgType === "module";
-        if (isEsmPkg) {
-            const compiledHref = await transpileTsModuleToTemp(resolvedPath);
-            try {
-                const imported = (await importByHref(compiledHref));
-                const config = imported?.default ?? imported?.config ?? imported ?? {};
-                return { path: resolvedPath, config };
-            }
-            finally {
-                cleanupTempModule(compiledHref);
-            }
-        }
-        const previous = process.env.TS_NODE_COMPILER_OPTIONS;
-        // register ts-node on demand so TypeScript configs can be required
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        require("ts-node/register/transpile-only");
+        const compiledPath = await transpileTsModuleToTemp(resolvedPath, isEsmPkg ? "esm" : "cjs");
         try {
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
-            const required = require(resolvedPath);
-            const config = required?.default ?? required?.config ?? required ?? {};
+            const imported = isEsmPkg
+                ? (await importByHref((0, url_1.pathToFileURL)(compiledPath).href))
+                : // eslint-disable-next-line @typescript-eslint/no-var-requires
+                    require(compiledPath);
+            const config = imported?.default ?? imported?.config ?? imported ?? {};
             return { path: resolvedPath, config };
         }
         finally {
-            if (previous === undefined) {
-                delete process.env.TS_NODE_COMPILER_OPTIONS;
-            }
-            else {
-                process.env.TS_NODE_COMPILER_OPTIONS = previous;
-            }
+            cleanupTempModule(compiledPath);
         }
     }
     const imported = (await importByHref((0, url_1.pathToFileURL)(resolvedPath).href));
@@ -162,6 +144,10 @@ function resolvePaths(cfgPath, config) {
         throw new Error("cms0: config.entry is required");
     }
     const baseDir = path_1.default.dirname(cfgPath);
+    const packageJsonPath = findNearestPackageJson(cfgPath);
+    const projectRoot = packageJsonPath
+        ? path_1.default.dirname(packageJsonPath)
+        : baseDir;
     const entryFile = path_1.default.resolve(baseDir, config.entry);
     const tsconfigPath = config.tsconfig
         ? path_1.default.resolve(baseDir, config.tsconfig)
@@ -171,6 +157,7 @@ function resolvePaths(cfgPath, config) {
     return {
         configPath: cfgPath,
         entryFile,
+        projectRoot,
         tsconfigPath,
         apiBaseUrl,
         apiKey,
@@ -190,12 +177,12 @@ function findTsConfig(entryFile) {
     }
     return undefined;
 }
-async function transpileTsModuleToTemp(tsPath) {
+async function transpileTsModuleToTemp(tsPath, format) {
     const ts = await Promise.resolve().then(() => __importStar(require("typescript")));
     const source = fs_1.default.readFileSync(tsPath, "utf8");
     const transpiled = ts.transpileModule(source, {
         compilerOptions: {
-            module: ts.ModuleKind.ESNext,
+            module: format === "esm" ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS,
             target: ts.ScriptTarget.ES2022,
             esModuleInterop: true,
         },
@@ -203,16 +190,15 @@ async function transpileTsModuleToTemp(tsPath) {
     });
     const hash = crypto_1.default
         .createHash("sha1")
-        .update(tsPath + source + Date.now().toString())
+        .update(tsPath + format + source + Date.now().toString())
         .digest("hex");
-    const outFile = path_1.default.join(path_1.default.dirname(tsPath), `.cms0-config.${hash}.mjs`);
+    const outFile = path_1.default.join(path_1.default.dirname(tsPath), `.cms0-config.${hash}.${format === "esm" ? "mjs" : "cjs"}`);
     fs_1.default.writeFileSync(outFile, transpiled.outputText, "utf8");
-    return (0, url_1.pathToFileURL)(outFile).href;
+    return outFile;
 }
-function cleanupTempModule(tempHref) {
+function cleanupTempModule(tempPath) {
     try {
-        const filePath = (0, url_1.fileURLToPath)(tempHref);
-        fs_1.default.unlinkSync(filePath);
+        fs_1.default.unlinkSync(tempPath);
     }
     catch {
         // ignore cleanup failures

package/dist/cjs/libs/cli/descriptor-writer.cjs

@@ -3,10 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FALLBACK_DESCRIPTOR = void 0;
 exports.writeDescriptorFiles = writeDescriptorFiles;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const paths_js_1 = require("./paths.cjs");
+const FALLBACK_DESCRIPTOR = {
+    models: {},
+    roots: {},
+    metadata: {
+        __cms0Fallback: true,
+    },
+};
+exports.FALLBACK_DESCRIPTOR = FALLBACK_DESCRIPTOR;
 function safeWrite(outputPath, output) {
     try {
         fs_1.default.mkdirSync(path_1.default.dirname(outputPath), { recursive: true });
@@ -21,19 +30,22 @@ function safeWrite(outputPath, output) {
         }
     }
 }
-function createSourceTsOutput(descriptor) {
-    return `// Auto-generated schema descriptor\nexport const schemaDescriptor = ${JSON.stringify(descriptor, null, 2)} as const;\n`;
+function createCjsOutput(descriptor) {
+    return `// Auto-generated schema descriptor\nexports.schemaDescriptor = ${JSON.stringify(descriptor, null, 2)};\n`;
+}
+function createJsonOutput(descriptor) {
+    return `${JSON.stringify(descriptor, null, 2)}\n`;
 }
 function createEsmOutput(descriptor) {
     return `// Auto-generated schema descriptor\nexport const schemaDescriptor = ${JSON.stringify(descriptor, null, 2)};\n`;
 }
-function createCjsOutput(descriptor) {
-    return `// Auto-generated schema descriptor\nexports.schemaDescriptor = ${JSON.stringify(descriptor, null, 2)};\n`;
-}
-function writeDescriptorFiles(descriptor) {
-    if (fs_1.default.existsSync(path_1.default.resolve(path_1.default.dirname(paths_js_1.descriptorOutputPaths.sourceTs), ".."))) {
-        safeWrite(paths_js_1.descriptorOutputPaths.sourceTs, createSourceTsOutput(descriptor));
-    }
+function writeBundledDescriptorProjection(descriptor) {
     safeWrite(paths_js_1.descriptorOutputPaths.esmJs, createEsmOutput(descriptor));
     safeWrite(paths_js_1.descriptorOutputPaths.cjsJs, createCjsOutput(descriptor));
 }
+function writeDescriptorFiles(resolved, descriptor, browserTarget = "sidecar") {
+    const localDescriptorOutputPaths = (0, paths_js_1.resolveLocalDescriptorOutputPaths)(resolved.projectRoot);
+    safeWrite(localDescriptorOutputPaths.json, createJsonOutput(descriptor));
+    safeWrite(localDescriptorOutputPaths.cjsJs, createCjsOutput(descriptor));
+    writeBundledDescriptorProjection(browserTarget === "bundle" ? descriptor : FALLBACK_DESCRIPTOR);
+}

package/dist/cjs/libs/cli/paths.cjs

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.packageRoot = exports.descriptorOutputPaths = void 0;
+exports.resolveLocalDescriptorOutputPaths = resolveLocalDescriptorOutputPaths;
 // Path utilities for locating package-relative outputs.
 const path_1 = __importDefault(require("path"));
 const node_fs_1 = __importDefault(require("node:fs"));
@@ -53,3 +54,9 @@ const descriptorOutputPaths = {
     cjsJs: path_1.default.resolve(packageRoot, "dist/cjs/generated/schema-descriptor.cjs"),
 };
 exports.descriptorOutputPaths = descriptorOutputPaths;
+function resolveLocalDescriptorOutputPaths(projectRoot) {
+    return {
+        json: path_1.default.resolve(projectRoot, ".cms0/generated/schema-descriptor.json"),
+        cjsJs: path_1.default.resolve(projectRoot, ".cms0/generated/schema-descriptor.cjs"),
+    };
+}