@cms0/cms0 0.2.17 → 0.2.19

package/dist/esm/index.js

@@ -1,5 +1,5 @@
 import { attachCms0ProvenanceRoot, enableCms0ProvenanceTracking, isCms0CanvasTransportEnabled, registerCms0CollectionItemIdentity, } from "@cms0/cms0/provenance";
-import { schemaDescriptor } from "@cms0/cms0/schema-descriptors";
+import { getActiveSchemaDescriptor, resolveBrowserSchemaDescriptor, } from "@cms0/cms0/schema-descriptors";
 import { buildZodSchemasFromDescriptor, decodeTaggedUnionValue, getUnionBranchKeys, } from "@cms0/shared";
 import { getCustomInlineTypeMetadata } from "./custom-types/registry.js";
 const DEFAULT_MODEL_NORMALIZATION_CONCURRENCY = 8;
@@ -547,7 +547,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)
@@ -575,14 +575,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);
@@ -602,12 +617,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)) {
@@ -631,7 +650,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)) {
@@ -649,7 +668,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,
@@ -672,7 +691,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,
@@ -692,12 +711,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;
             }
@@ -720,7 +739,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 ||
@@ -743,12 +762,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,
@@ -766,7 +785,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, {
@@ -775,11 +794,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,
@@ -792,7 +811,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,
@@ -802,7 +821,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
@@ -834,7 +853,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);
@@ -855,7 +874,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,
@@ -863,7 +882,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,
@@ -978,6 +997,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;
@@ -1138,6 +1173,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
@@ -1230,6 +1268,8 @@ async function runResource(resource, descriptor, baseUrl, apiKey, defaultLocale,
             defaultLocale,
             assetUrlBuilder,
             modelNormalizationConcurrency: DEFAULT_MODEL_NORMALIZATION_CONCURRENCY,
+            includeProjectionPaths,
+            excludeProjectionPaths,
         },
     };
     if (resource.isCollection && !byId) {
@@ -1245,17 +1285,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);
 }
 export function createCmsClient(descriptor, config) {
@@ -1340,7 +1386,65 @@ export function createCmsClient(descriptor, config) {
     return rootProxy;
 }
 export function cms0(config) {
-    return createCmsClient(schemaDescriptor, config);
+    if (typeof window !== "undefined") {
+        return createLazyBrowserCmsClient(config);
+    }
+    return createCmsClient(getActiveSchemaDescriptor(), config);
+}
+function createLazyBrowserCmsClient(config) {
+    let clientPromise = null;
+    const resolveClient = async () => {
+        if (!clientPromise) {
+            clientPromise = 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;
 }
-export { activateCms0CanvasTransport, attachCms0ProvenanceRoot, captureCms0Provenance, enableCms0ProvenanceTracking, readCms0CanvasTransportCollectionItemId, readCms0CollectionItemIdentity, registerCms0LiveRoot, registerCms0CollectionItemIdentity, readCms0LiveRoots, readCms0ProvenanceValueMeta, restoreCms0CanvasTransportMetadata, unwrapCms0CanvasTransportValue, } from "./provenance.js";
+export { activateCms0CanvasTransport, attachCms0ProvenanceRoot, captureCms0Provenance, dehydrateCms0CanvasTransportValue, dehydrateCms0CanvasVisibleValue, enableCms0ProvenanceTracking, readCms0CanvasTransportCollectionItemId, readCms0CollectionItemIdentity, registerCms0LiveRoot, registerCms0CollectionItemIdentity, readCms0LiveRoots, readCms0ProvenanceValueMeta, restoreCms0CanvasTransportMetadata, unwrapCms0CanvasTransportValue, } from "./provenance.js";
 export { resolveLocalized, toNextMetadata, toOpenGraph, toTwitter, } from "./seo.js";

package/dist/esm/libs/cli/browser-sidecar.js

@@ -0,0 +1,51 @@
+import http from "node:http";
+import { getCms0DescriptorSidecarPort } from "../../descriptor-sidecar.js";
+function startBrowserDescriptorSidecar(resolved, initialDescriptor) {
+    const port = getCms0DescriptorSidecarPort(resolved.apiBaseUrl, resolved.apiKey);
+    let currentDescriptor = initialDescriptor;
+    const server = http.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();
+                        });
+                    });
+                },
+            });
+        });
+    });
+}
+export { startBrowserDescriptorSidecar };

package/dist/esm/libs/cli/build.js

@@ -2,9 +2,9 @@
 import { buildDescriptorAlt as buildDescriptor } from "./descriptor-builder-alt.js";
 import { publishDescriptor } from "./publisher.js";
 import { writeDescriptorFiles } from "./descriptor-writer.js";
-function buildOnce(resolved) {
+function buildOnce(resolved, browserTarget = "sidecar") {
     const descriptor = buildDescriptor(resolved);
-    writeDescriptorFiles(descriptor);
+    writeDescriptorFiles(resolved, descriptor, browserTarget);
     publishDescriptor(resolved, descriptor);
     return descriptor;
 }

package/dist/esm/libs/cli/cli.js

@@ -1,6 +1,7 @@
 // CLI entry point: parse arguments, load config, and trigger build/watch modes.
 import { pathToFileURL } from "url";
 import { buildOnce } from "./build.js";
+import { startBrowserDescriptorSidecar } from "./browser-sidecar.js";
 import { loadUserConfig, resolvePaths } from "./config-loader.js";
 import { startWatcher } from "./watcher.js";
 async function runFromCli() {
@@ -26,14 +27,18 @@ async function runFromCli() {
     const resolved = resolvePaths(loaded.path, loaded.config);
     console.log("resolved: ", resolved);
     if (mode === "watch") {
-        startWatcher(resolved);
+        const descriptor = buildOnce(resolved, "sidecar");
+        const sidecar = await startBrowserDescriptorSidecar(resolved, descriptor);
+        startWatcher(resolved, (nextDescriptor) => sidecar.updateDescriptor(nextDescriptor), "sidecar", false);
         return;
     }
     if (mode === "dev") {
-        startWatcher(resolved);
+        const descriptor = buildOnce(resolved, "sidecar");
+        const sidecar = await startBrowserDescriptorSidecar(resolved, descriptor);
+        startWatcher(resolved, (nextDescriptor) => sidecar.updateDescriptor(nextDescriptor), "sidecar", false);
         return;
     }
-    buildOnce(resolved);
+    buildOnce(resolved, "bundle");
 }
 // ESM/CJS-safe main check without import.meta syntax in the source so CJS builds succeed.
 const isDirectRun = (() => {

package/dist/esm/libs/cli/config-loader.js

@@ -1,7 +1,7 @@
 // Load cms0.config files and resolve relevant paths for the CLI.
 import fs from "fs";
 import path from "path";
-import { pathToFileURL, fileURLToPath } from "url";
+import { pathToFileURL } from "url";
 import crypto from "crypto";
 const DEFAULT_CONFIG_BASENAMES = [
     "cms0.config.ts",
@@ -70,38 +70,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(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(pathToFileURL(resolvedPath).href));
@@ -118,6 +100,10 @@ function resolvePaths(cfgPath, config) {
         throw new Error("cms0: config.entry is required");
     }
     const baseDir = path.dirname(cfgPath);
+    const packageJsonPath = findNearestPackageJson(cfgPath);
+    const projectRoot = packageJsonPath
+        ? path.dirname(packageJsonPath)
+        : baseDir;
     const entryFile = path.resolve(baseDir, config.entry);
     const tsconfigPath = config.tsconfig
         ? path.resolve(baseDir, config.tsconfig)
@@ -127,6 +113,7 @@ function resolvePaths(cfgPath, config) {
     return {
         configPath: cfgPath,
         entryFile,
+        projectRoot,
         tsconfigPath,
         apiBaseUrl,
         apiKey,
@@ -146,12 +133,12 @@ function findTsConfig(entryFile) {
     }
     return undefined;
 }
-async function transpileTsModuleToTemp(tsPath) {
+async function transpileTsModuleToTemp(tsPath, format) {
     const ts = await import("typescript");
     const source = fs.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,
         },
@@ -159,16 +146,15 @@ async function transpileTsModuleToTemp(tsPath) {
     });
     const hash = crypto
         .createHash("sha1")
-        .update(tsPath + source + Date.now().toString())
+        .update(tsPath + format + source + Date.now().toString())
         .digest("hex");
-    const outFile = path.join(path.dirname(tsPath), `.cms0-config.${hash}.mjs`);
+    const outFile = path.join(path.dirname(tsPath), `.cms0-config.${hash}.${format === "esm" ? "mjs" : "cjs"}`);
     fs.writeFileSync(outFile, transpiled.outputText, "utf8");
-    return pathToFileURL(outFile).href;
+    return outFile;
 }
-function cleanupTempModule(tempHref) {
+function cleanupTempModule(tempPath) {
     try {
-        const filePath = fileURLToPath(tempHref);
-        fs.unlinkSync(filePath);
+        fs.unlinkSync(tempPath);
     }
     catch {
         // ignore cleanup failures

package/dist/esm/libs/cli/descriptor-writer.js

@@ -1,6 +1,13 @@
 import fs from "fs";
 import path from "path";
-import { descriptorOutputPaths } from "./paths.js";
+import { descriptorOutputPaths, resolveLocalDescriptorOutputPaths } from "./paths.js";
+const FALLBACK_DESCRIPTOR = {
+    models: {},
+    roots: {},
+    metadata: {
+        __cms0Fallback: true,
+    },
+};
 function safeWrite(outputPath, output) {
     try {
         fs.mkdirSync(path.dirname(outputPath), { recursive: true });
@@ -15,20 +22,23 @@ 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.existsSync(path.resolve(path.dirname(descriptorOutputPaths.sourceTs), ".."))) {
-        safeWrite(descriptorOutputPaths.sourceTs, createSourceTsOutput(descriptor));
-    }
+function writeBundledDescriptorProjection(descriptor) {
     safeWrite(descriptorOutputPaths.esmJs, createEsmOutput(descriptor));
     safeWrite(descriptorOutputPaths.cjsJs, createCjsOutput(descriptor));
 }
-export { writeDescriptorFiles };
+function writeDescriptorFiles(resolved, descriptor, browserTarget = "sidecar") {
+    const localDescriptorOutputPaths = resolveLocalDescriptorOutputPaths(resolved.projectRoot);
+    safeWrite(localDescriptorOutputPaths.json, createJsonOutput(descriptor));
+    safeWrite(localDescriptorOutputPaths.cjsJs, createCjsOutput(descriptor));
+    writeBundledDescriptorProjection(browserTarget === "bundle" ? descriptor : FALLBACK_DESCRIPTOR);
+}
+export { FALLBACK_DESCRIPTOR, writeDescriptorFiles };

package/dist/esm/libs/cli/paths.js

@@ -45,4 +45,10 @@ const descriptorOutputPaths = {
     esmJs: path.resolve(packageRoot, "dist/esm/generated/schema-descriptor.js"),
     cjsJs: path.resolve(packageRoot, "dist/cjs/generated/schema-descriptor.cjs"),
 };
-export { descriptorOutputPaths, packageRoot };
+function resolveLocalDescriptorOutputPaths(projectRoot) {
+    return {
+        json: path.resolve(projectRoot, ".cms0/generated/schema-descriptor.json"),
+        cjsJs: path.resolve(projectRoot, ".cms0/generated/schema-descriptor.cjs"),
+    };
+}
+export { descriptorOutputPaths, packageRoot, resolveLocalDescriptorOutputPaths };

package/dist/esm/libs/cli/watcher.js

@@ -1,13 +1,13 @@
 // File watcher that rebuilds descriptors on entry changes.
 import chokidar from "chokidar";
 import { buildOnce } from "./build.js";
-function startWatcher(resolved, afterBuild) {
+function startWatcher(resolved, afterBuild, browserTarget = "sidecar", runInitialBuild = true) {
     const watcher = chokidar.watch([resolved.entryFile], {
         ignoreInitial: false,
     });
     const run = (after) => {
         try {
-            const descriptor = buildOnce(resolved);
+            const descriptor = buildOnce(resolved, browserTarget);
             if (after) {
                 Promise.resolve(after(descriptor)).catch((err) => {
                     console.error("cms0: post-build hook failed", err);
@@ -19,7 +19,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);