@cms0/cms0 0.2.17 → 0.2.18

package/dist/cjs/schema-descriptors.cjs

@@ -1,5 +1,198 @@
 "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.getActiveSchemaDescriptor = getActiveSchemaDescriptor;
+exports.syncActiveSchemaDescriptorGlobals = syncActiveSchemaDescriptorGlobals;
+const schema_descriptor_1 = require("@cms0/cms0/generated/schema-descriptor");
+const LOCAL_DESCRIPTOR_RELATIVE_SEGMENTS = [
+    ".cms0",
+    "generated",
+    "schema-descriptor.json",
+];
+let cachedLocalDescriptor = null;
+exports.schemaDescriptor = schema_descriptor_1.schemaDescriptor;
+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 getActiveSchemaDescriptor() {
+    if (typeof window !== "undefined") {
+        return (readGlobalSchemaDescriptor() ??
+            schema_descriptor_1.schemaDescriptor);
+    }
+    return resolveActiveSchemaDescriptor();
+}
+function resolveActiveSchemaDescriptor() {
+    return (readLocalSchemaDescriptor() ??
+        schema_descriptor_1.schemaDescriptor);
+}
+function syncActiveSchemaDescriptorGlobals() {
+    const activeDescriptor = resolveActiveSchemaDescriptor();
+    const globals = globalThis;
+    globals.__CMS0_SCHEMA_DESCRIPTOR__ = activeDescriptor;
+    globals.__CMS0_CANVAS_SCHEMA_DESCRIPTOR__ = activeDescriptor;
+    return activeDescriptor;
+}

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, } 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,7 @@ export function createCmsClient(descriptor, config) {
     return rootProxy;
 }
 export function cms0(config) {
-    return createCmsClient(schemaDescriptor, config);
+    return createCmsClient(getActiveSchemaDescriptor(), config);
 }
-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/build.js

@@ -4,7 +4,7 @@ import { publishDescriptor } from "./publisher.js";
 import { writeDescriptorFiles } from "./descriptor-writer.js";
 function buildOnce(resolved) {
     const descriptor = buildDescriptor(resolved);
-    writeDescriptorFiles(descriptor);
+    writeDescriptorFiles(resolved, descriptor);
     publishDescriptor(resolved, descriptor);
     return descriptor;
 }

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,6 @@
 import fs from "fs";
 import path from "path";
-import { descriptorOutputPaths } from "./paths.js";
+import { descriptorOutputPaths, resolveLocalDescriptorOutputPaths } from "./paths.js";
 function safeWrite(outputPath, output) {
     try {
         fs.mkdirSync(path.dirname(outputPath), { recursive: true });
@@ -24,11 +24,17 @@ function createEsmOutput(descriptor) {
 function createCjsOutput(descriptor) {
     return `// Auto-generated schema descriptor\nexports.schemaDescriptor = ${JSON.stringify(descriptor, null, 2)};\n`;
 }
-function writeDescriptorFiles(descriptor) {
+function createJsonOutput(descriptor) {
+    return `${JSON.stringify(descriptor, null, 2)}\n`;
+}
+function writeDescriptorFiles(resolved, descriptor) {
+    const localDescriptorOutputPaths = resolveLocalDescriptorOutputPaths(resolved.projectRoot);
     if (fs.existsSync(path.resolve(path.dirname(descriptorOutputPaths.sourceTs), ".."))) {
         safeWrite(descriptorOutputPaths.sourceTs, createSourceTsOutput(descriptor));
     }
     safeWrite(descriptorOutputPaths.esmJs, createEsmOutput(descriptor));
     safeWrite(descriptorOutputPaths.cjsJs, createCjsOutput(descriptor));
+    safeWrite(localDescriptorOutputPaths.json, createJsonOutput(descriptor));
+    safeWrite(localDescriptorOutputPaths.cjsJs, createCjsOutput(descriptor));
 }
 export { 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 };