@lowdefy/build 4.5.2 → 4.7.0

package/dist/build/jit/addInstalledTypes.js

@@ -0,0 +1,51 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import fs from 'fs';
+import path from 'path';
+function getInstalledPackages(directories) {
+    if (!directories.server) return null;
+    const pkgPath = path.join(directories.server, 'package.json');
+    if (!fs.existsSync(pkgPath)) return null;
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    return new Set(Object.keys(pkg.dependencies ?? {}));
+}
+// In dev mode, page content is built JIT so page-level types (actions, blocks,
+// operators) aren't counted during skeleton build. Include all types from
+// installed packages so they're available for client-side use. Dev server
+// pre-installs default packages so bundle size is not a concern — only
+// production builds tree-shake by counting exact type usage.
+function addInstalledTypes({ components, context }) {
+    const installedPackages = getInstalledPackages(context.directories);
+    if (!installedPackages) return;
+    const addTypes = (store, definitions)=>{
+        for (const [typeName, def] of Object.entries(definitions)){
+            if (!store[typeName] && installedPackages.has(def.package)) {
+                store[typeName] = {
+                    originalTypeName: def.originalTypeName,
+                    package: def.package,
+                    version: def.version,
+                    count: 0
+                };
+            }
+        }
+    };
+    addTypes(components.types.actions, context.typesMap.actions);
+    addTypes(components.types.blocks, context.typesMap.blocks);
+    addTypes(components.types.operators.client, context.typesMap.operators.client);
+    addTypes(components.types.operators.server, context.typesMap.operators.server);
+    // Expose installedPackages on context for later use (e.g., writing build artifact)
+    context.installedPackages = installedPackages;
+}
+export default addInstalledTypes;

package/dist/build/jit/buildJsShallow.js

@@ -0,0 +1,41 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import jsMapParser from '../buildJs/jsMapParser.js';
+function buildJsShallow({ components, context }) {
+    // Extract JS from api/connections (page JS is built JIT)
+    if (components.api) {
+        components.api = jsMapParser({
+            input: components.api,
+            jsMap: context.jsMap,
+            env: 'server'
+        });
+    }
+    if (components.connections) {
+        components.connections = jsMapParser({
+            input: components.connections,
+            jsMap: context.jsMap,
+            env: 'server'
+        });
+    }
+    // Ensure both client and server jsMap keys exist.
+    // Page JS extraction is deferred to JIT build.
+    if (!context.jsMap.client) {
+        context.jsMap.client = {};
+    }
+    if (!context.jsMap.server) {
+        context.jsMap.server = {};
+    }
+}
+export default buildJsShallow;

package/dist/build/jit/buildPageJit.js

@@ -0,0 +1,271 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import fs from 'fs';
+import path from 'path';
+import { serializer, type } from '@lowdefy/helpers';
+import { ConfigError, LowdefyInternalError } from '@lowdefy/errors';
+import operators from '@lowdefy/operators-js/operators/build';
+import addKeys from '../addKeys.js';
+import buildPage from '../buildPages/buildPage.js';
+import validateLinkReferences from '../buildPages/validateLinkReferences.js';
+import validatePayloadReferences from '../buildPages/validatePayloadReferences.js';
+import validateServerStateReferences from '../buildPages/validateServerStateReferences.js';
+import validateStateReferences from '../buildPages/validateStateReferences.js';
+import collectDynamicIdentifiers from '../collectDynamicIdentifiers.js';
+import createCheckDuplicateId from '../../utils/createCheckDuplicateId.js';
+import createContext from '../../createContext.js';
+import evaluateStaticOperators from '../buildRefs/evaluateStaticOperators.js';
+import getRefContent from '../buildRefs/getRefContent.js';
+import jsMapParser from '../buildJs/jsMapParser.js';
+import makeRefDefinition from '../buildRefs/makeRefDefinition.js';
+import { resolve, WalkContext, cloneForResolve, tagRefDeep } from '../buildRefs/walker.js';
+import validateOperatorsDynamic from '../validateOperatorsDynamic.js';
+import writeMaps from '../writeMaps.js';
+import detectMissingPluginPackages from './detectMissingPluginPackages.js';
+import updateServerPackageJsonJit from './updateServerPackageJsonJit.js';
+import validatePageTypes from './validatePageTypes.js';
+import writePageJit from './writePageJit.js';
+validateOperatorsDynamic({
+    operators
+});
+const dynamicIdentifiers = collectDynamicIdentifiers({
+    operators
+});
+async function buildPageJit({ pageId, pageRegistry, context, directories, logger }) {
+    // Use provided context or create a minimal one for JIT builds
+    const buildContext = context ?? createContext({
+        directories,
+        logger: logger ?? console,
+        stage: 'dev'
+    });
+    const pageEntry = type.isFunction(pageRegistry.get) ? pageRegistry.get(pageId) : pageRegistry[pageId];
+    if (!pageEntry) {
+        return null;
+    }
+    // Reset errors for this build. Keep a local reference so that concurrent
+    // JIT builds (different pages sharing buildContext) cannot corrupt our
+    // error list by reassigning buildContext.errors during an await.
+    const buildErrors = [];
+    buildContext.errors = buildErrors;
+    try {
+        // Pages without a source file (e.g., default 404) can only be served from
+        // their pre-built artifact — they have no YAML to re-resolve from.
+        // All user pages (with refId) always JIT-resolve from source YAML so that
+        // page-only edits are picked up without a skeleton rebuild.
+        if (!pageEntry.refId) {
+            const pagePath = path.join(buildContext.directories.build, 'pages', pageId, `${pageId}.json`);
+            try {
+                const content = await fs.promises.readFile(pagePath, 'utf8');
+                return serializer.deserialize(JSON.parse(content));
+            } catch (err) {
+                if (err.code !== 'ENOENT') throw err;
+            }
+        }
+        // Resolve the page file from scratch using the source file path determined
+        // by createPageRegistry's parent chain walk.
+        if (!pageEntry.refPath && !pageEntry.resolverOriginal) {
+            throw new ConfigError(`Page "${pageId}" has no source file reference. Cannot resolve page content.`);
+        }
+        // Resolve unresolved vars (which may contain inner _ref objects) fresh from disk.
+        // For resolver pages, unresolved vars live in resolverOriginal.vars (single source).
+        // For file-backed pages, they're stored separately in unresolvedVars.
+        const unresolvedVars = pageEntry.unresolvedVars ?? pageEntry.resolverOriginal?.vars;
+        let resolvedVars = null;
+        if (unresolvedVars) {
+            const varRefDef = makeRefDefinition({}, null, buildContext.refMap);
+            const varCtx = new WalkContext({
+                buildContext,
+                refId: varRefDef.id,
+                sourceRefId: null,
+                vars: {},
+                path: '',
+                currentFile: pageEntry.refPath ?? pageEntry.resolverOriginal?.resolver ?? '',
+                refChain: new Set(),
+                operators,
+                env: process.env,
+                dynamicIdentifiers,
+                shouldStop: null
+            });
+            resolvedVars = await resolve(cloneForResolve(unresolvedVars), varCtx);
+        }
+        let refDef;
+        if (pageEntry.resolverOriginal) {
+            const resolverDefinition = resolvedVars ? {
+                ...pageEntry.resolverOriginal,
+                vars: resolvedVars
+            } : pageEntry.resolverOriginal;
+            refDef = makeRefDefinition(resolverDefinition, null, buildContext.refMap);
+            buildContext.refMap[refDef.id].path = null;
+        } else {
+            const refDefinition = resolvedVars ? {
+                path: pageEntry.refPath,
+                vars: resolvedVars
+            } : pageEntry.refPath;
+            refDef = makeRefDefinition(refDefinition, null, buildContext.refMap);
+            buildContext.refMap[refDef.id].path = refDef.path;
+        }
+        const pageContent = await getRefContent({
+            context: buildContext,
+            refDef,
+            referencedFrom: null
+        });
+        const pageCtx = new WalkContext({
+            buildContext,
+            refId: refDef.id,
+            sourceRefId: null,
+            vars: refDef.vars ?? {},
+            path: '',
+            currentFile: refDef.path ?? '',
+            refChain: new Set(),
+            operators,
+            env: process.env,
+            dynamicIdentifiers,
+            shouldStop: null
+        });
+        let processed = await resolve(pageContent, pageCtx);
+        processed = evaluateStaticOperators({
+            context: buildContext,
+            input: processed,
+            refDef
+        });
+        // When resolving from a collection file (with vars), the result is an array of pages.
+        // Find the specific page by ID.
+        if (type.isArray(processed)) {
+            processed = processed.find((p)=>type.isObject(p) && p.id === pageId);
+            if (!processed) {
+                throw new ConfigError(`Page "${pageId}" not found in resolved page source file.`);
+            }
+        }
+        // Tag all objects with ~r for ref provenance (normally done inside _ref
+        // resolution by the walker; JIT resolves the page file directly).
+        tagRefDeep(processed, refDef.id);
+        // Apply skeleton-computed auth (buildAuth ran during skeleton build)
+        processed.auth = pageEntry.auth;
+        // Add keys to the resolved page
+        addKeys({
+            components: processed,
+            context: buildContext
+        });
+        // Write keyMap/refMap so the error handler reads JIT entries from disk.
+        // JIT addKeys assigns fresh ~k values that aren't in the skeleton keyMap.
+        await writeMaps({
+            context: buildContext
+        });
+        // Initialize linkActionRefs for buildPage (normally done by buildPages)
+        if (!buildContext.linkActionRefs) {
+            buildContext.linkActionRefs = [];
+        }
+        // Build the page (validation, block processing)
+        const checkDuplicatePageId = createCheckDuplicateId({
+            message: 'Duplicate pageId "{{ id }}".'
+        });
+        buildPage({
+            page: processed,
+            index: 0,
+            context: buildContext,
+            checkDuplicatePageId
+        });
+        // Validate that all page-level types (blocks, actions, operators) exist
+        validatePageTypes({
+            context: buildContext
+        });
+        // Detect plugin packages that are in typesMap but not installed in server
+        const missingPackages = detectMissingPluginPackages({
+            context: buildContext,
+            installedPluginPackages: buildContext.installedPluginPackages
+        });
+        if (missingPackages.size > 0) {
+            if (buildContext.directories.server) {
+                await updateServerPackageJsonJit({
+                    directories: buildContext.directories,
+                    missingPackages
+                });
+            }
+            return {
+                installing: true,
+                packages: [
+                    ...missingPackages.keys()
+                ]
+            };
+        }
+        // Validate link, state, payload, and server-state references
+        const pageIds = Object.keys(pageRegistry);
+        validateLinkReferences({
+            linkActionRefs: buildContext.linkActionRefs,
+            pageIds,
+            context: buildContext
+        });
+        validateStateReferences({
+            page: processed,
+            context: buildContext
+        });
+        validatePayloadReferences({
+            page: processed,
+            context: buildContext
+        });
+        validateServerStateReferences({
+            page: processed,
+            context: buildContext
+        });
+        // Extract JS functions from the page
+        const pageRequests = [
+            ...processed.requests ?? []
+        ];
+        delete processed.requests;
+        const cleanPage = jsMapParser({
+            input: processed,
+            jsMap: buildContext.jsMap,
+            env: 'client'
+        });
+        const cleanRequests = jsMapParser({
+            input: pageRequests,
+            jsMap: buildContext.jsMap,
+            env: 'server'
+        });
+        const finalPage = {
+            ...cleanPage,
+            requests: cleanRequests
+        };
+        // Check for collected errors from validation steps
+        if (buildErrors.length > 0) {
+            const error = new ConfigError(`Page "${pageId}" build failed with ${buildErrors.length} error(s).`);
+            error.buildErrors = buildErrors;
+            throw error;
+        }
+        // Write page artifacts
+        await writePageJit({
+            page: finalPage,
+            context: buildContext
+        });
+        return finalPage;
+    } catch (err) {
+        // Attach any collected errors to the thrown error
+        if (buildErrors.length > 0 && !err.buildErrors) {
+            err.buildErrors = [
+                err,
+                ...buildErrors
+            ];
+        }
+        if (err.isLowdefyError) {
+            throw err;
+        }
+        const lowdefyErr = new LowdefyInternalError(err.message, {
+            cause: err
+        });
+        lowdefyErr.buildErrors = err.buildErrors;
+        throw lowdefyErr;
+    }
+}
+export default buildPageJit;

package/dist/build/jit/buildShallowPages.js

@@ -0,0 +1,90 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { serializer } from '@lowdefy/helpers';
+import buildPage from '../buildPages/buildPage.js';
+import jsMapParser from '../buildJs/jsMapParser.js';
+import createCheckDuplicateId from '../../utils/createCheckDuplicateId.js';
+import createPageRegistry from './createPageRegistry.js';
+import PAGE_CONTENT_KEYS from './pageContentKeys.js';
+function buildShallowPages({ components, context }) {
+    // Set pageId on all pages (normally done by buildPage in buildPages).
+    // Must run before createPageRegistry which uses page.id as map key.
+    for (const page of components.pages ?? []){
+        if (page.id && !page.pageId) {
+            page.pageId = page.id;
+        }
+    }
+    const pageRegistry = createPageRegistry({
+        components,
+        context
+    });
+    const checkDuplicatePageId = createCheckDuplicateId({
+        message: 'Duplicate pageId "{{ id }}".'
+    });
+    for (const page of components.pages ?? []){
+        checkDuplicatePageId({
+            id: page.id,
+            configKey: page['~k']
+        });
+    }
+    // Build sourceless pages (e.g., default 404) — no YAML to JIT-resolve from.
+    context.linkActionRefs = [];
+    const sourcelessPageArtifacts = [];
+    (components.pages ?? []).forEach((page, index)=>{
+        const entry = pageRegistry.get(page.id);
+        // Skip pages with a source file (JIT-resolved) and resolver pages (JIT re-run)
+        if (!entry || entry.refPath !== null || entry.resolverOriginal) return;
+        buildPage({
+            page,
+            index,
+            context
+        });
+        const pageRequests = [
+            ...page.requests ?? []
+        ];
+        delete page.requests;
+        const cleanPage = jsMapParser({
+            input: page,
+            jsMap: context.jsMap,
+            env: 'client'
+        });
+        const cleanRequests = jsMapParser({
+            input: pageRequests,
+            jsMap: context.jsMap,
+            env: 'server'
+        });
+        const builtPage = {
+            ...cleanPage,
+            requests: cleanRequests
+        };
+        sourcelessPageArtifacts.push({
+            pageId: builtPage.pageId,
+            pageJson: serializer.serializeToString(builtPage),
+            requests: (builtPage.requests ?? []).map((req)=>({
+                    requestId: req.requestId,
+                    requestJson: serializer.serializeToString(req)
+                }))
+        });
+        // Strip content for subsequent skeleton steps
+        for (const key of PAGE_CONTENT_KEYS){
+            delete page[key];
+        }
+    });
+    return {
+        pageRegistry,
+        sourcelessPageArtifacts
+    };
+}
+export default buildShallowPages;

package/dist/build/jit/createPageRegistry.js

@@ -0,0 +1,85 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { type } from '@lowdefy/helpers';
+// Walk up from ~r to find the page's source file for JIT re-resolution.
+// Templates receive vars (they need id, title, etc. from the page file),
+// while page files are self-contained or receive vars from a collection file.
+// Stop at the first ref called WITHOUT vars — that's the page file.
+// When ALL refs have vars (module pages), fall back to the first child of root.
+// When the child of root has no path (resolver ref), go shallower — capture
+// the resolver's info so JIT can re-run it with freshly resolved vars.
+function findPageSourceRef(refId, refMap, unresolvedRefVars) {
+    let current = refId;
+    let firstChildOfRoot = null;
+    while(!type.isNone(current)){
+        const entry = refMap[current];
+        if (!entry) {
+            return null;
+        }
+        const hasVars = !type.isNone(unresolvedRefVars[current]);
+        // Track the first child of root as fallback
+        const parentEntry = !type.isNone(entry.parent) ? refMap[entry.parent] : null;
+        if (parentEntry && type.isNone(parentEntry.parent) && !firstChildOfRoot) {
+            // Resolver ref: capture the resolver's original definition and vars
+            // so JIT can re-run the resolver (instead of falling through to the
+            // template file below it, which would discard the resolver's vars).
+            firstChildOfRoot = entry.path ? {
+                path: entry.path,
+                unresolvedVars: unresolvedRefVars[current] ?? null
+            } : {
+                path: null,
+                original: refMap[current].original
+            };
+        }
+        // First ref without vars = self-contained page file
+        if (!hasVars) {
+            if (!type.isNone(entry.parent)) {
+                return {
+                    path: entry.path,
+                    unresolvedVars: null
+                };
+            }
+            // Reached root — use first child of root
+            return firstChildOfRoot;
+        }
+        current = entry.parent;
+    }
+    return firstChildOfRoot;
+}
+function createPageRegistry({ components, context }) {
+    const registry = new Map();
+    const unresolvedRefVars = context.unresolvedRefVars ?? {};
+    (components.pages ?? []).forEach((page)=>{
+        // Read ~r from keyMap — addKeys moves ~r there and deletes it from objects.
+        const keyMapEntry = context.keyMap[page['~k']];
+        const refId = keyMapEntry?.['~r'] ?? null;
+        const sourceRef = !type.isNone(refId) ? findPageSourceRef(refId, context.refMap, unresolvedRefVars) : null;
+        // Inline pages (defined directly in lowdefy.yaml) have a refId pointing to
+        // the root ref but findPageSourceRef returns null because there is no
+        // separate source file. Set refId to null so buildPageJit serves them from
+        // the pre-built artifact written by buildShallowPages.
+        const isInline = !type.isNone(refId) && sourceRef === null && !type.isNone(context.refMap[refId]) && type.isNone(context.refMap[refId].parent);
+        registry.set(page.id, {
+            pageId: page.id,
+            auth: page.auth,
+            refId: isInline ? null : refId,
+            refPath: sourceRef?.path ?? null,
+            unresolvedVars: sourceRef?.unresolvedVars ?? null,
+            resolverOriginal: sourceRef?.original ?? null
+        });
+    });
+    return registry;
+}
+export default createPageRegistry;

package/dist/build/jit/detectMissingPluginPackages.js

@@ -0,0 +1,62 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ function collectMissing({ counter, definitions, installedPluginPackages, missingPackages }) {
+    const counts = counter.getCounts();
+    for (const typeName of Object.keys(counts)){
+        const def = definitions[typeName];
+        if (!def) continue;
+        if (installedPluginPackages.has(def.package)) continue;
+        if (!missingPackages.has(def.package)) {
+            missingPackages.set(def.package, {
+                version: def.version,
+                types: []
+            });
+        }
+        missingPackages.get(def.package).types.push(typeName);
+    }
+}
+function detectMissingPluginPackages({ context, installedPluginPackages }) {
+    const missingPackages = new Map();
+    if (!installedPluginPackages) {
+        return missingPackages;
+    }
+    const { typeCounters, typesMap } = context;
+    collectMissing({
+        counter: typeCounters.blocks,
+        definitions: typesMap.blocks,
+        installedPluginPackages,
+        missingPackages
+    });
+    collectMissing({
+        counter: typeCounters.actions,
+        definitions: typesMap.actions,
+        installedPluginPackages,
+        missingPackages
+    });
+    collectMissing({
+        counter: typeCounters.operators.client,
+        definitions: typesMap.operators.client,
+        installedPluginPackages,
+        missingPackages
+    });
+    collectMissing({
+        counter: typeCounters.operators.server,
+        definitions: typesMap.operators.server,
+        installedPluginPackages,
+        missingPackages
+    });
+    return missingPackages;
+}
+export default detectMissingPluginPackages;

package/dist/build/jit/isPageContentPath.js

@@ -0,0 +1,24 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import PAGE_CONTENT_KEYS from './pageContentKeys.js';
+function isPageContentPath(jsonPath) {
+    if (!jsonPath.startsWith('pages.')) return false;
+    const segments = jsonPath.split('.');
+    for(let i = 1; i < segments.length; i++){
+        if (PAGE_CONTENT_KEYS.includes(segments[i])) return true;
+    }
+    return false;
+}
+export default isPageContentPath;

package/dist/build/jit/pageContentKeys.js

@@ -0,0 +1,26 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // Keys stripped from pages after createPageRegistry captures the page file ref.
+// Only `id`, `type` (and skeleton-computed `pageId`, `auth`, `~k`, `~r`) survive.
+// `type` is always a resolved string (never a ref target) and must stay on stubs
+// for schema validation (block schema requires both `id` and `type`).
+const PAGE_CONTENT_KEYS = [
+    'blocks',
+    'areas',
+    'events',
+    'requests',
+    'layout'
+];
+export default PAGE_CONTENT_KEYS;