@antelopejs/interface-dms 0.9.1 → 0.10.1

package/dist/page/metadata.js

@@ -1,82 +1,127 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PageMetadata = void 0;
-const interface_api_1 = require("@antelopejs/interface-api");
-const interface_core_1 = require("@antelopejs/interface-core");
-const logging_1 = require("@antelopejs/interface-core/logging");
-const auth_1 = require("../auth");
-// Import from the defining leaf, not the dms-base barrel: the barrel pulls in
-// table-view, which imports the page interface back — entering through the
-// barrel would then call DefaultLayout() while the barrel is still
-// mid-evaluation.
-const layouts_1 = require("../base/layouts");
-const component_1 = require("../component");
-const component_slots_1 = require("../internal/component-slots");
-const db_1 = require("../db");
-const guards_1 = require("../guards");
-const permissions_1 = require("../permissions");
-const tenant_scoped_model_1 = require("../tenant-scoped-model");
-const tenant_access_1 = require("../tenant-access");
-const tenant_access_2 = require("../internal/tenant-access");
 const uploads_1 = require("../uploads");
-// Categories resolve controller classes through PageMetadata; neither module
-// dereferences the other during evaluation.
-// oxlint-disable import/no-cycle
-const categories_1 = require("./categories");
-const categories_2 = require("./internal/categories");
-const component_tree_1 = require("./internal/component-tree");
-const extension_assembly_1 = require("./internal/extension-assembly");
-const extension_validation_1 = require("./internal/extension-validation");
-const declaration_conflict_1 = require("./declaration-conflict");
-const page_routes_1 = require("./page-routes");
-const layout_filter_1 = require("./layout-filter");
-const layout_filter_2 = require("./internal/layout-filter");
-const page_record_1 = require("./internal/page-record");
-const member_access_1 = require("./internal/member-access");
-const table_view_ids_1 = require("./internal/table-view-ids");
-const registry_1 = require("./internal/registry");
-const page_registration_1 = require("./internal/page-registration");
-const metadata_helpers_1 = require("./internal/metadata-helpers");
-const NATIVE_UPLOAD_FIELD_TYPES = new Set(["file", "image"]);
-function isNativeUploadField(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const node = value;
-    return (typeof node.type === "string" &&
-        NATIVE_UPLOAD_FIELD_TYPES.has(node.type) &&
-        !!node.component &&
-        typeof node.component === "object");
-}
-function readUploadConstraints(options) {
-    const declared = options.constraints;
-    if (!declared || typeof declared !== "object")
-        return undefined;
-    const constraints = {};
-    if (typeof declared.maxSize === "number")
-        constraints.maxSize = declared.maxSize;
-    if (Array.isArray(declared.allowedMimetypes))
-        constraints.allowedMimetypes = declared.allowedMimetypes.filter((mimetype) => typeof mimetype === "string");
-    return constraints;
-}
-function resolveWritePermission(componentName, component, path) {
-    if (componentName !== "dms-table-view")
-        return component.getAction("submit")?.permissionId;
-    const action = { new: "add", edit: "edit" };
-    const mode = Object.keys(action).find((key) => path.includes(key));
-    if (mode)
-        return (component.getAction(action[mode])?.permissionId ??
-            "__native_upload_disabled__");
-    return "__native_upload_disabled__";
-}
-// Only a page that declared components has hidden them all: one declaring
-// none has nothing to explain.
-function hiddenComponentsFlag(declared, served) {
-    const hidesAll = Object.keys(declared).length > 0 && Object.keys(served).length === 0;
-    return hidesAll ? { allComponentsHidden: true } : {};
-}
+// oxlint-disable-next-line import/no-cycle -- Category proxies are read after evaluation.
+const metadata = __importStar(require("./internal/metadata-lifecycle"));
 class PageMetadata {
     target;
     static key = Symbol();
+    static {
+        metadata.installMetadataOwner((page) => ({
+            get registration() {
+                return page.registration;
+            },
+            get componentMap() {
+                return page.componentMap;
+            },
+            get componentTrees() {
+                return page.componentTrees;
+            },
+            get nativeUploadFields() {
+                return page.nativeUploadFields;
+            },
+            get notifiedComponents() {
+                return page.notifiedComponents;
+            },
+            get extensionEntries() {
+                return page.extensionEntries;
+            },
+            get layoutRef() {
+                return page.layoutRef;
+            },
+            get ownComponents() {
+                return page.ownComponents;
+            },
+            set ownComponents(value) {
+                page.ownComponents = value;
+            },
+            get detached() {
+                return page.detached;
+            },
+            set detached(value) {
+                page.detached = value;
+            },
+            get moduleScoped() {
+                return page.moduleScoped;
+            },
+            set moduleScoped(value) {
+                page.moduleScoped = value;
+            },
+            get skipComponentPermissions() {
+                return page.skipComponentPermissions;
+            },
+            set skipComponentPermissions(value) {
+                page.skipComponentPermissions = value;
+            },
+            get pagePermissionId() {
+                return page.pagePermissionId;
+            },
+            set pagePermissionId(value) {
+                page.pagePermissionId = value;
+            },
+            get registeredPagePermission() {
+                return page.registeredPagePermission;
+            },
+            set registeredPagePermission(value) {
+                page.registeredPagePermission = value;
+            },
+            registerPermission: (info) => page.registerPagePermission(info),
+            ownsPermissions: () => page.ownsPagePermissions(),
+            ownProperties: () => page.ownRouteProperties(),
+            auth: (info) => page.applyAuthDecorators(info),
+            route: (info) => page.registerLayoutRoute(info),
+            permissionId: (key) => page.componentPermissionId(key),
+            unregister: (component, key) => page.unregisterComponent(component, key),
+            register: (node) => page.registerComponentNode(node),
+            unregisterNode: (node) => page.unregisterComponentNode(node),
+            registersPermissions: () => page.registersComponentPermissions(),
+            actions: (component) => page.actionPermissions(component),
+            actionsForNode: (node) => page.actionPermissions(node.component),
+            notify: (node) => page.notifyPageCreated(node),
+            bind: (serialized, key) => page.bindNativeUploadFields(serialized, page.componentPermissionId(key)),
+            takenKeys: () => page.takenComponentKeys(),
+            path: (contribution) => page.extensionComponentPath(contribution),
+            prepareExtension: (contribution, path) => page.prepareComponent(contribution.component, path),
+            unregisterExtension: (contribution) => page.unregisterComponent(contribution.component, page.extensionComponentPath(contribution)),
+            drop: (info) => page.dropExtension(info),
+            rebuild: () => page.rebuildLayoutComponents(),
+            releaseGate: () => page.releaseOwnComponentsGate(),
+        }));
+    }
     pageInfo;
     layout;
     components = {};
@@ -92,13 +137,8 @@ class PageMetadata {
     nativeUploadFields = new Map();
     /** Exact live positions of a component, including mounts on multiple pages. */
     ComponentPermissionIds(component) {
-        return [...this.componentMap.values()]
-            .filter((node) => node.component === component && node.access === "own")
-            .map((node) => node.permissionId);
+        return metadata.componentPermissionIds(this, component);
     }
-    // What each declared component actually claimed, so the teardown gives back
-    // exactly that — the tree is read from the component itself, which a hot
-    // reload may have rebuilt by then.
     componentTrees = new Map();
     notifiedComponents = new Set();
     extensionEntries = new Map();
@@ -115,7 +155,7 @@ class PageMetadata {
     ownComponentsGate = Promise.resolve();
     releaseOwnComponentsGate = () => undefined;
     detached = false;
-    registration = new page_registration_1.PageRegistration();
+    registration = new metadata.PageRegistration();
     pagePermissionId = "";
     registeredPagePermission = false;
     skipComponentPermissions = false;
@@ -124,60 +164,20 @@ class PageMetadata {
         this.target = target;
     }
     inherit(parent) {
-        const merge = (src, dst) => {
-            if (src) {
-                if (dst) {
-                    return { ...dst, ...src };
-                }
-                else {
-                    return { ...src };
-                }
-            }
-            else {
-                return dst;
-            }
-        };
-        this.pageInfo = merge(parent.pageInfo, this.pageInfo);
-        this.layout = merge(parent.layout, this.layout);
-        this.components = merge(parent.components, this.components) ?? {};
+        metadata.inherit(this, parent);
     }
     SetComponent(id, component) {
         this.components[id] = component;
     }
     SetInfo(id, fullSlug, menuOptions, pageLayout) {
-        const { parent, ...menu } = menuOptions;
-        const resolvedCategory = (0, categories_2.resolveCategoryInfo)(menu.category);
-        const parentFullId = resolvedCategory?.fullId ?? "";
-        const fullId = parentFullId ? `${parentFullId}.${id}` : id;
-        const location = (0, page_routes_1.pageRoutePath)(fullSlug, "/pagelayout");
-        const pageInfo = {
-            ...menu,
-            category: resolvedCategory,
-            id,
-            fullId,
-            fullSlug,
-            layoutUrl: location,
-            parentSlug: parent ? (0, categories_2.resolveCategoryInfo)(parent)?.fullSlug : undefined,
-            hidden: menu.hidden || resolvedCategory?.hidden,
-            publicAccess: menu.publicAccess || resolvedCategory?.publicAccess,
-            authOnly: menu.authOnly || resolvedCategory?.authOnly,
-            memberAccess: menu.memberAccess ||
-                (0, member_access_1.inheritedMemberAccess)(resolvedCategory?.memberAccess),
-            bypassTenantAccessGate: menu.bypassTenantAccessGate || resolvedCategory?.bypassTenantAccessGate,
-        };
-        this.layout =
-            pageLayout ??
-                menu.layout ??
-                (0, categories_2.resolveInheritedLayout)(resolvedCategory) ??
-                (0, layouts_1.DefaultLayout)();
-        this.pageInfo = pageInfo;
+        metadata.setPageInfo(this, id, fullSlug, menuOptions, pageLayout);
     }
     async Register() {
         const pageInfo = this.pageInfo;
         if (!pageInfo) {
             throw new Error("PageMetadata not properly initialized");
         }
-        this.registration = new page_registration_1.PageRegistration();
+        this.registration = new metadata.PageRegistration();
         this.layoutRef = { layout: this.layout, components: {} };
         this.ownComponents = {};
         this.componentMap = new Map();
@@ -185,17 +185,9 @@ class PageMetadata {
         this.notifiedComponents = new Set();
         this.extensionEntries = new Map();
         this.detached = false;
-        // Shut before the page is published: from that point an extension can find
-        // it and try to graft onto it. Everything that follows runs inside the try,
-        // so nothing failing on the way can leave the gate shut — a page whose gate
-        // stays shut holds every sync on it, teardowns included.
         this.closeOwnComponentsGate();
         try {
             this.publish(pageInfo);
-            // Every permission is registered before the first await, so
-            // GetResponsibleModule() still sees the registering module's frame:
-            // resolved from an async continuation it returns nothing, and the
-            // core's own sweep then has no module to attribute them to.
             const prepared = Object.entries(this.components).map(([key, component]) => this.prepareComponent(component, key));
             for (const prepare of prepared) {
                 const { key, serialized } = await prepare();
@@ -205,9 +197,6 @@ class PageMetadata {
             this.rebuildLayoutComponents();
         }
         catch (error) {
-            // A half-registered page is worse than none: it sits in the registry,
-            // routed, with no layout to serve. Detached with it, so a sync held back
-            // by the gate does not graft extensions onto the wreck once released.
             this.detached = true;
             this.registration.dispose();
             throw error;
@@ -215,8 +204,8 @@ class PageMetadata {
         finally {
             this.releaseOwnComponentsGate();
         }
-        if (registry_1.pageExtensions.has(pageInfo.fullId)) {
-            await (0, registry_1.syncTargetExtensions)(pageInfo.fullId);
+        if (metadata.pageExtensions.has(pageInfo.fullId)) {
+            await metadata.syncTargetExtensions(pageInfo.fullId);
         }
     }
     /**
@@ -231,40 +220,7 @@ class PageMetadata {
      * later extensions would graft themselves onto.
      */
     publish(pageInfo) {
-        const previous = registry_1.pageMetadataByFullId.get(pageInfo.fullId);
-        registry_1.pageMetadataByFullId.set(pageInfo.fullId, this);
-        this.registration.track(() => {
-            if (registry_1.pageMetadataByFullId.get(pageInfo.fullId) === this) {
-                registry_1.pageMetadataByFullId.delete(pageInfo.fullId);
-            }
-        });
-        if (previous && previous !== this) {
-            previous.Dispose();
-        }
-        (0, registry_1.stampPageRegistration)(pageInfo);
-        categories_1.internal.RegisterPage.register(pageInfo);
-        this.registration.track(() => {
-            categories_1.internal.RegisterPage.unregister(pageInfo);
-        });
-        this.moduleScoped = (0, categories_1.isInsideModule)(pageInfo);
-        this.skipComponentPermissions =
-            pageInfo.noComponentPermissions === true || pageInfo.authOnly === true;
-        this.pagePermissionId = this.registerPagePermission(pageInfo);
-        registry_1.permissionMap.set(this.target, this.pagePermissionId);
-        this.registration.track(() => {
-            if (!this.ownsPagePermissions())
-                return;
-            registry_1.permissionMap.delete(this.target);
-            if (this.registeredPagePermission && this.pagePermissionId) {
-                (0, permissions_1.UnregisterPermission)(this.pagePermissionId);
-                this.registeredPagePermission = false;
-            }
-        });
-        this.ownRouteProperties();
-        this.applyAuthDecorators(pageInfo);
-        (0, metadata_helpers_1.RequestQueryProperty)()(this.target.prototype, "pageQuery");
-        (0, metadata_helpers_1.RequestRouteParametersProperty)()(this.target.prototype, "pageParams");
-        this.registerLayoutRoute(pageInfo);
+        metadata.publish(this, pageInfo);
     }
     /**
      * Take down everything this registration created. Idempotent, and safe to
@@ -274,20 +230,7 @@ class PageMetadata {
      * @internal
      */
     Dispose() {
-        this.detached = true;
-        this.releaseOwnComponentsGate();
-        // Extensions belong to other modules: they survive this page and re-apply
-        // if it registers again, but nothing of theirs may outlive it in the
-        // permission tree. Synchronous, unlike registration, so a hot reload that
-        // re-registers immediately cannot have this land on the replacement.
-        // Snapshot: dropExtension deletes from the map being iterated.
-        // oxlint-disable-next-line unicorn/no-useless-spread
-        for (const info of [...this.extensionEntries.keys()]) {
-            this.dropExtension(info);
-        }
-        this.rebuildLayoutComponents();
-        this.ownComponents = {};
-        this.registration.dispose();
+        metadata.dispose(this);
     }
     /**
      * Bring the page's injected components in line with the extensions currently
@@ -304,8 +247,6 @@ class PageMetadata {
         const run = this.extensionSyncQueue
             .then(() => this.awaitOwnComponents())
             .then(() => this.applyRegisteredExtensions());
-        // The queue itself must never stay rejected, or a single failed sync would
-        // silently freeze every later registration and teardown on this page.
         this.extensionSyncQueue = run.catch(() => undefined);
         return run;
     }
@@ -327,15 +268,12 @@ class PageMetadata {
      * @internal Read by the menu, which leaves such a page out.
      */
     async HidesEveryComponent(permissions) {
-        if (this.pageInfo?.publicAccess === true || this.skipComponentPermissions) {
-            return false;
-        }
-        const keys = Object.keys(this.layoutRef?.components ?? {});
-        if (keys.length === 0)
+        const keys = metadata.permissionKeys(this);
+        if (!keys)
             return false;
         for (const key of keys) {
             const permissionId = this.componentPermissionId(key);
-            if (await (0, permissions_1.HasPermission)(permissions, permissionId))
+            if (await metadata.HasPermission(permissions, permissionId))
                 return false;
         }
         return true;
@@ -357,9 +295,6 @@ class PageMetadata {
     }
     closeOwnComponentsGate() {
         this.ownComponentsReady = false;
-        // Release the gate being replaced before dropping the only handle on its
-        // resolver: whoever waits on it would otherwise wait on a promise nobody
-        // can settle any more. `awaitOwnComponents` catches them up with this one.
         this.releaseOwnComponentsGate();
         this.ownComponentsGate = new Promise((resolve) => {
             this.releaseOwnComponentsGate = resolve;
@@ -368,15 +303,8 @@ class PageMetadata {
     async applyRegisteredExtensions() {
         const infos = this.detached
             ? []
-            : (registry_1.pageExtensions.get(this.pageInfo?.fullId ?? "") ?? []);
-        const desired = new Set(infos);
-        // Snapshot: dropExtension deletes from the map being iterated.
-        // oxlint-disable-next-line unicorn/no-useless-spread
-        for (const info of [...this.extensionEntries.keys()]) {
-            if (!desired.has(info)) {
-                this.dropExtension(info);
-            }
-        }
+            : (metadata.pageExtensions.get(this.pageInfo?.fullId ?? "") ?? []);
+        metadata.removeStaleExtensions(this, infos);
         for (const info of infos) {
             if (!this.extensionEntries.has(info)) {
                 await this.addExtension(info);
@@ -385,141 +313,45 @@ class PageMetadata {
         this.rebuildLayoutComponents();
     }
     registerPagePermission(pageInfo) {
-        const fromAction = pageInfo.permission instanceof component_1.Action
-            ? pageInfo.permission.toPermission()
-            : undefined;
-        const pagePermission = fromAction ?? {
-            id: pageInfo.fullId,
-            title: pageInfo.displayName,
-            icon: pageInfo.icon,
-            defaultGranted: pageInfo.publicAccess || (0, member_access_1.opensToMembers)(pageInfo.memberAccess),
-            ...pageInfo.permission,
-        };
-        this.registeredPagePermission = false;
-        if (this.moduleScoped) {
-            (0, permissions_1.MarkModuleScopedPermission)(pagePermission.id);
-        }
-        else if (!fromAction && pageInfo.authOnly !== true) {
-            (0, permissions_1.RegisterPermission)(pagePermission.id, pagePermission);
-            this.registeredPagePermission = true;
-        }
-        return pagePermission.id;
+        return metadata.registerPermission(this, pageInfo);
     }
     registerLayoutRoute(pageInfo) {
-        const apimeta = (0, interface_core_1.GetMetadata)(this.target, interface_api_1.ControllerMeta);
-        const resolvePageLayout = (request) => this.resolvePageLayout(request);
-        // The by-slug entry carries no guard of its own, so it asks the resolver
-        // to assert the gate; the route below is already guarded.
-        const handler = (request) => this.resolvePageLayout(request, { enforceTenantAccessGate: true });
-        registry_1.pageLayoutHandlers.set(pageInfo.fullSlug, handler);
-        const routeId = (0, interface_api_1.RegisterRoute)({
-            location: pageInfo.layoutUrl,
-            callback: async function () {
-                return resolvePageLayout({
-                    user: this.user,
-                    memberModel: this.memberModel,
-                    roleModel: this.roleModel,
-                    tenantId: this.tenantId,
-                    query: this.pageQuery,
-                    params: this.pageParams,
-                });
-            },
-            method: "GET",
-            mode: "handler",
-            parameters: [],
-            properties: apimeta.computed_props,
-            proto: this.target.prototype,
-        });
-        this.registration.track(() => {
-            if (registry_1.pageLayoutHandlers.get(pageInfo.fullSlug) === handler) {
-                registry_1.pageLayoutHandlers.delete(pageInfo.fullSlug);
-            }
-            // …and the page's own HTTP route. The by-slug entry used to be the only
-            // half taken down, so an unregistered page kept answering on its direct
-            // route for as long as its module stayed loaded — the very thing the
-            // by-slug cleanup was added to prevent.
-            (0, interface_api_1.UnregisterRoute)(routeId);
+        metadata.registerLayoutRoute(() => this.target, pageInfo, () => this.registration, (request) => this.resolvePageLayout(request), (request, options) => this.resolvePageLayout(request, options));
+    }
+    async resolvePageLayout({ user, memberModel, roleModel, tenantId, query, params, resolverContext, }, { enforceTenantAccessGate = false } = {}) {
+        const layout = metadata.registeredLayout(this);
+        if (metadata.tenantGateRequired(this, enforceTenantAccessGate, user)) {
+            await metadata.AssertTenantAccess(user._id, tenantId);
+        }
+        const components = await metadata.ResolveComponentSlots(layout.components);
+        const { loadPermissions, context } = metadata.prepareLayoutContext({
+            user,
+            memberModel,
+            roleModel,
+            tenantId,
+            query,
+            params,
+            resolverContext,
         });
-    }
-    async resolvePageLayout({ user, memberModel, roleModel, tenantId, query, params, resolverContext, }, 
-    // Only for the by-slug entry, which has no guard of its own.
-    { enforceTenantAccessGate = false } = {}) {
-        const layout = this.layoutRef;
-        if (!layout) {
-            throw new Error("PageMetadata not properly initialized");
-        }
-        // Only for the by-slug entry: the page's own route already asserts the
-        // gate through its auth decorators, and asserting again would cost every
-        // page load a second sweep of user-supplied gate callbacks. `/dms/pagelayout`
-        // has no such guard — it asks for a session and nothing else — so without
-        // this the page-level `bypassTenantAccessGate` flag would be advisory: a
-        // member of a denied tenant could read the layout, upload tokens included,
-        // of every page that did not opt out.
-        //
-        // Which surfaces survive a denial is `gateAllowsSurface`'s call, shared
-        // with the menu and realtime page access so the three cannot drift.
-        if (enforceTenantAccessGate &&
-            user &&
-            this.pageInfo &&
-            !(0, tenant_access_2.gateAllowsSurface)(this.pageInfo, true)) {
-            await (0, tenant_access_1.AssertTenantAccess)(user._id, tenantId);
-        }
-        // Slots are resolved per request rather than baked into the cached layout:
-        // a component that opens one is answering contributors that may register at
-        // any time, long after this page did. Resolved *before* the permission
-        // filter, so contributed content goes through every filter the page's own
-        // content does — a contributed watch guarded by `requirePermission`
-        // included.
-        const components = await (0, component_slots_1.ResolveComponentSlots)(layout.components);
-        // Upload tokens are already baked into the cached layout: each form
-        // stamped its own fields when it serialized, at registration
-        // (`SignUploadToken` in interfaces/dms/uploads).
-        const loadPermissions = async () => {
-            if (!user)
-                return new Set();
-            const roleIds = (await memberModel.getByUser(user._id))?.roleIds ?? [];
-            return (0, permissions_1.GetEffectiveUserPermissions)(user, tenantId, roleIds, roleModel, resolverContext);
-        };
-        // Header actions declaring a permission are filtered on every page, even
-        // one skipping component permissions: they name their own requirement.
-        // The page's record is read first, so every availability of the page
-        // reads it with the URL.
-        const context = { tenantId, user, query, params };
-        const read = await (0, page_record_1.readPageRecord)(layout.layout, context);
+        const read = await metadata.readPageRecord(layout.layout, context);
         context.record = read?.record;
         if (this.pageInfo?.publicAccess === true || this.skipComponentPermissions) {
-            return {
-                ...layout,
-                layout: (0, layout_filter_2.withComponentHeaderButtons)(await (0, layout_filter_2.filterLayoutHeaderActions)(layout.layout, loadPermissions, context, this.pagePermissionId, read?.status), components),
-                components: (0, table_view_ids_1.withTableViewPlacements)(components),
-            };
+            const respond = metadata.prepareLayoutResponse(layout, components);
+            return respond(await metadata.filterPageHeader(this, layout, loadPermissions, context, read));
         }
         const permissions = await loadPermissions();
-        const servedComponents = await (0, layout_filter_1.filterComponents)(components, this.pagePermissionId, permissions, this.componentMap, context);
-        return {
-            ...layout,
-            // A component's header buttons are added once it was filtered: the
-            // ones the caller may not press are gone already.
-            layout: (0, layout_filter_2.withComponentHeaderButtons)(await (0, layout_filter_2.filterLayoutHeaderActions)(layout.layout, async () => permissions, context, this.pagePermissionId, read?.status), servedComponents),
-            components: (0, table_view_ids_1.withTableViewPlacements)(servedComponents),
-            ...hiddenComponentsFlag(components, servedComponents),
-        };
+        const served = await metadata.filterPageComponents(this, components, permissions, context);
+        const respond = metadata.prepareFilteredLayoutResponse(layout, components, served);
+        return respond(await metadata.filterPageHeader(this, layout, async () => permissions, context, read));
     }
-    // Component and action ids descend from the page permission id, so a module
-    // page's mark already covers them — they only need to stay out of the
-    // grantable permission tree.
     registersComponentPermissions() {
         return !this.skipComponentPermissions && !this.moduleScoped;
     }
-    componentPermissionId(componentKey) {
-        return `${this.pagePermissionId}.${componentKey}`;
+    componentPermissionId(key) {
+        return `${this.pagePermissionId}.${key}`;
     }
     actionPermissions(component) {
-        const grantsMembers = (0, member_access_1.opensToMembers)(this.pageInfo?.memberAccess);
-        return Object.values(component.actions)
-            .map((action) => action.toPermission())
-            .filter((permission) => !!permission)
-            .map((permission) => grantsMembers ? { ...permission, defaultGranted: true } : permission);
+        return metadata.actionPermissions(component, this.pageInfo);
     }
     /**
      * Claim a component's permissions now, and hand back the serialization to
@@ -535,113 +367,37 @@ class PageMetadata {
      * of its position: they take part in per-request filtering under that id, so
      * a child that never claimed it would have its `onFilter` skipped.
      */
-    prepareComponent(component, componentKey) {
-        const nodes = (0, component_tree_1.collectComponentTree)(component, this.componentPermissionId(componentKey));
-        this.componentTrees.set(componentKey, nodes);
-        // Tracked before anything is claimed: `onPageCreated` is consumer code and
-        // can throw between the permission being registered and the end of this
-        // method, and the rollback can only undo what it was told about.
-        this.registration.track(() => {
-            this.unregisterComponent(component, componentKey);
-        });
-        for (const node of nodes) {
-            this.registerComponentNode(node);
-        }
-        return async () => {
-            const serialized = await component.serialize();
-            if (this.detached || this.componentTrees.get(componentKey) !== nodes)
-                return { key: componentKey, serialized };
-            await this.bindNativeUploadFields(serialized, this.componentPermissionId(componentKey));
-            return { key: componentKey, serialized };
-        };
+    prepareComponent(component, key) {
+        return metadata.prepareComponent(this, component, key);
     }
-    async bindNativeUploadFields(serialized, componentId) {
-        if (this.detached || this.componentMap.get(componentId)?.access !== "own")
+    async bindNativeUploadFields(serialized, id) {
+        if (!metadata.prepareUploadOptions(this, serialized, id))
             return;
-        if (serialized.options)
-            serialized.options = JSON.parse(JSON.stringify(serialized.options));
-        await this.bindUploadOptions(serialized.options, serialized.componentName, componentId, []);
+        await this.bindUploadOptions(serialized.options, serialized.componentName, id, []);
         for (const child of serialized.children ?? []) {
-            await this.bindNativeUploadFields(child.component, `${componentId}.${child.id}`);
+            await this.bindNativeUploadFields(child.component, `${id}.${child.id}`);
         }
     }
-    async bindUploadOptions(value, componentName, componentId, path) {
+    async bindUploadOptions(value, name, id, path) {
+        // oxlint-disable-next-line anti-slop/no-runtime-typeof -- Serialized options may be primitives; recurse only through objects.
         if (!value || typeof value !== "object")
             return;
-        if (isNativeUploadField(value)) {
-            await this.registerNativeUploadField(value, componentName, componentId, path);
+        if (metadata.isNativeUploadField(value)) {
+            await this.registerNativeUploadField(value, name, id, path);
         }
         for (const [key, child] of Object.entries(value)) {
-            await this.bindUploadOptions(child, componentName, componentId, [
-                ...path,
-                key,
-            ]);
+            await this.bindUploadOptions(child, name, id, [...path, key]);
         }
     }
-    async registerNativeUploadField(node, componentName, componentId, path) {
-        const mount = this.componentMap.get(componentId);
-        if (this.detached || mount?.access !== "own")
+    async registerNativeUploadField(node, name, id, path) {
+        const phase = metadata.prepareUploadRegistration(this, node, name, id, path);
+        if (!phase)
             return;
-        const options = node.component.options ?? {};
-        node.component.options = options;
-        const registration = {
-            pageId: this.pageInfo?.fullId ?? "",
-            componentId,
-            storage: typeof options.storage === "string" ? options.storage : undefined,
-            path: typeof options.path === "string" ? options.path : undefined,
-            field: typeof options.attachmentField === "string"
-                ? options.attachmentField
-                : path.join("/"),
-            visibility: options.visibility === "public" ? "public" : "private",
-            writePermission: node.disabled
-                ? "__native_upload_disabled__"
-                : resolveWritePermission(componentName, mount.component, path),
-            readPermissions: this.registersComponentPermissions() && !this.pageInfo?.publicAccess
-                ? componentId
-                    .slice(this.pagePermissionId.length + 1)
-                    .split(".")
-                    .map((_, index, parts) => `${this.pagePermissionId}.${parts.slice(0, index + 1).join(".")}`)
-                : [],
-            constraints: readUploadConstraints(options),
-        };
-        options.uploadToken = await (0, uploads_1.SignUploadToken)(registration);
-        if (this.detached || this.componentMap.get(componentId) !== mount)
-            return;
-        uploads_1.internal.RegisterNativeUploadField.register(registration);
-        const fields = this.nativeUploadFields.get(componentId) ?? [];
-        fields.push(registration);
-        this.nativeUploadFields.set(componentId, fields);
+        phase.options.uploadToken = await (0, uploads_1.SignUploadToken)(phase.registration);
+        metadata.finishUploadRegistration(this, phase);
     }
     registerComponentNode(node) {
-        const { component, permissionId } = node;
-        this.componentMap.set(permissionId, node);
-        // A withheld position claims nothing: its id belongs to an action, and it
-        // is in the map only so the filter can refuse it. Its hook stays unrun —
-        // a component that is never served must not register side effects.
-        if (node.access === "withheld")
-            return;
-        // First position wins, and the walk is parent-first: a component mounted
-        // both by the page and inside another keeps the id it is declared under.
-        // Overwriting would make `GetPermissionId` — and every guard built on it —
-        // depend on walk order.
-        if (node.access === "own" && !registry_1.permissionMap.has(component)) {
-            registry_1.permissionMap.set(component, permissionId);
-        }
-        if (this.registersComponentPermissions() && node.access === "own") {
-            (0, permissions_1.RegisterPermission)(permissionId, {
-                id: permissionId,
-                title: component.metadata.name,
-                icon: component.metadata.icon,
-                description: component.metadata.description,
-                defaultGranted: (0, member_access_1.opensToMembers)(this.pageInfo?.memberAccess),
-            });
-        }
-        this.notifyPageCreated(node);
-        if (this.registersComponentPermissions()) {
-            for (const actionPermission of this.actionPermissions(component)) {
-                (0, permissions_1.RegisterPermission)(actionPermission.id, actionPermission);
-            }
-        }
+        metadata.registerComponentNode(this, node);
     }
     /**
      * Run a component's `onCreated` hook, once per registration whatever the
@@ -656,26 +412,7 @@ class PageMetadata {
      * a half-registered page is worse than none.
      */
     notifyPageCreated(node) {
-        if (!node.component.onPageCreated)
-            return;
-        if (this.notifiedComponents.has(node.component))
-            return;
-        this.notifiedComponents.add(node.component);
-        if (node.depth === 0) {
-            node.component.onPageCreated(this);
-            return;
-        }
-        try {
-            node.component.onPageCreated(this);
-        }
-        catch (error) {
-            // …except what two components both claim (a form route, the writing
-            // TableView of a controller): the page cannot honour both declarations,
-            // and carrying on would silently serve one of them in place of the other.
-            if (error instanceof declaration_conflict_1.PageDeclarationConflictError)
-                throw error;
-            logging_1.Logging.Error(`[dms] component "${node.permissionId}" failed its onCreated hook on page "${this.pageInfo?.fullId}": ${String(error)}`);
-        }
+        metadata.notifyPageCreated(this, node);
     }
     /**
      * A page's permission ids are derived from its `fullId`, so a metadata
@@ -684,77 +421,20 @@ class PageMetadata {
      * owner — or nobody, when the page is gone for good — may take them down.
      */
     ownsPagePermissions() {
-        const owner = registry_1.pageMetadataByFullId.get(this.pageInfo?.fullId ?? "");
-        return owner === undefined || owner === this;
-    }
-    // Nothing was prepared under this key — a teardown replayed after the
-    // extension that owned it was already dropped, or a walk that threw before
-    // claiming anything. Giving back what was never taken would unregister a
-    // permission another position still holds.
-    unregisterComponent(_component, componentKey) {
-        const nodes = this.componentTrees.get(componentKey);
-        if (!nodes)
-            return;
-        this.componentTrees.delete(componentKey);
-        for (const node of nodes) {
-            for (const field of this.nativeUploadFields.get(node.permissionId) ??
-                []) {
-                uploads_1.internal.RegisterNativeUploadField.unregister(field);
-            }
-            this.nativeUploadFields.delete(node.permissionId);
-            this.componentMap.delete(node.permissionId);
-            this.notifiedComponents.delete(node.component);
-        }
-        if (!this.ownsPagePermissions())
-            return;
-        for (const node of nodes) {
-            this.unregisterComponentNode(node);
-        }
+        return metadata.ownsPagePermissions(this);
+    }
+    unregisterComponent(_component, key) {
+        metadata.unregisterComponent(this, key);
     }
-    // Action ids are resolved through `permissionMap`, so the node's own entry
-    // only goes once its actions have been given back — and only when the entry
-    // is this position's, since another one may have claimed the instance first.
     unregisterComponentNode(node) {
-        if (node.access === "withheld")
-            return;
-        if (this.registersComponentPermissions()) {
-            for (const actionPermission of this.actionPermissions(node.component)) {
-                (0, permissions_1.UnregisterPermission)(actionPermission.id);
-            }
-        }
-        if (node.access !== "own")
-            return;
-        if (this.registersComponentPermissions()) {
-            (0, permissions_1.UnregisterPermission)(node.permissionId);
-        }
-        if (registry_1.permissionMap.get(node.component) === node.permissionId) {
-            registry_1.permissionMap.delete(node.component);
-        }
+        metadata.unregisterComponentNode(this, node);
     }
-    // A component is tracked before it is processed, so a detach landing mid-way
-    // still finds it. One that fails to register is taken back down and left out
-    // of the layout, while the rest of its extension stands: the extension is
-    // recorded either way, so a later sync never replays an `onPageCreated` side
-    // effect that already ran.
     async addExtension(info) {
-        const errors = (0, extension_validation_1.collectExtensionErrors)(info, {
-            own: this.ownComponents,
-            taken: this.takenComponentKeys(),
-        });
-        const entries = [];
-        // Recorded even when it contributes nothing: an extension the page refused
-        // must not be re-examined — and re-reported — on every later sync.
-        this.extensionEntries.set(info, entries);
-        if (errors.length > 0) {
-            for (const error of errors) {
-                logging_1.Logging.Error(`[dms] ${error}`);
-            }
+        const entries = metadata.prepareExtensionEntries(this, info);
+        if (!entries)
             return;
-        }
         for (const [declarationIndex, contribution] of info.components.entries()) {
-            // Revoked mid-way: its module is going away, and running in that
-            // module's context now would claim a generation that is being released.
-            if (!(0, registry_1.isPageExtensionRegistered)(info))
+            if (!metadata.isPageExtensionRegistered(info))
                 break;
             entries.push({
                 ...contribution,
@@ -762,20 +442,12 @@ class PageMetadata {
                 declarationIndex,
             });
             try {
-                const componentPath = this.extensionComponentPath(contribution);
-                // Both halves, as the extending module: the claim registers
-                // permissions and runs `onCreated`, the serialization binds native
-                // upload fields.
-                const prepare = (0, registry_1.runAsPageExtensionOwner)(info, () => this.prepareComponent(contribution.component, componentPath));
-                const { serialized } = await (0, registry_1.runAsPageExtensionOwner)(info, prepare);
+                const prepare = metadata.prepareExtensionComponent(this, info, contribution);
+                const { serialized } = await metadata.runAsPageExtensionOwner(info, prepare);
                 entries[entries.length - 1].serialized = serialized;
             }
             catch (error) {
-                entries.pop();
-                this.unregisterComponent(contribution.component, this.extensionComponentPath(contribution));
-                if (error instanceof declaration_conflict_1.PageDeclarationConflictError)
-                    throw error;
-                logging_1.Logging.Error(`[dms] page extension "${info.extensionName}" could not register component "${contribution.key}" on page "${info.targetFullId}": ${String(error)}`);
+                metadata.reportExtensionFailure(this, entries, info, contribution, error);
             }
         }
         if (this.detached) {
@@ -788,31 +460,16 @@ class PageMetadata {
      * because a page's components share one permission subtree.
      */
     takenComponentKeys() {
-        const owner = this.pageInfo?.fullId ?? "";
-        const taken = new Map(Object.keys(this.ownComponents).map((key) => [key, owner]));
-        for (const [info, entries] of this.extensionEntries) {
-            for (const entry of entries) {
-                taken.set(entry.key, info.extensionName);
-            }
-        }
-        return taken;
+        return metadata.takenKeys(this);
     }
     dropExtension(info) {
-        for (const entry of this.extensionEntries.get(info) ?? []) {
-            this.unregisterComponent(entry.component, this.extensionComponentPath(entry));
-        }
-        this.extensionEntries.delete(info);
+        metadata.dropExtension(this, info);
     }
     extensionComponentPath(component) {
-        const anchorPath = component.anchorPath ?? [];
-        if (anchorPath.length <= 1)
-            return component.key;
-        return [...anchorPath.slice(0, -1), component.key].join(".");
+        return metadata.extensionComponentPath(component);
     }
     rebuildLayoutComponents() {
-        if (!this.layoutRef)
-            return;
-        this.layoutRef.components = (0, extension_assembly_1.assembleLayoutComponents)(this.ownComponents, [...this.extensionEntries.values()].flat());
+        metadata.rebuildLayoutComponents(this);
     }
     /**
      * Give the page's controller its own copy of every route property it
@@ -826,33 +483,10 @@ class PageMetadata {
      * of its last form (`<table>.view`), and a form page for the one after it.
      */
     ownRouteProperties() {
-        const properties = (0, interface_core_1.GetMetadata)(this.target, interface_api_1.ControllerMeta).computed_props;
-        for (const [key, property] of Object.entries(properties)) {
-            properties[key] = { ...property, modifiers: [...property.modifiers] };
-        }
+        metadata.ownRouteProperties(this.target);
     }
     applyAuthDecorators(pageInfo) {
-        if (pageInfo.publicAccess === true)
-            return;
-        const authOnly = pageInfo.authOnly === true;
-        const isModulePage = (0, metadata_helpers_1.isPageInsideModule)(pageInfo);
-        this.guardOptions = {
-            bypassTenantAccessGate: pageInfo.bypassTenantAccessGate,
-        };
-        const authDecorator = authOnly
-            ? (0, auth_1.AuthUser)()
-            : isModulePage
-                ? (0, auth_1.AuthOwnerOnly)()
-                : (0, guards_1.AuthUserWithPermission)(this.target, this.guardOptions);
-        authDecorator(this.target.prototype, "user");
-        if (isModulePage && !authOnly) {
-            (0, metadata_helpers_1.logModuleRouteGated)(pageInfo.fullSlug);
-        }
-        if (authOnly)
-            return;
-        (0, tenant_scoped_model_1.TenantScopedModel)(db_1.RoleModel)(this.target.prototype, "roleModel");
-        (0, tenant_scoped_model_1.TenantScopedModel)(db_1.TenantMemberModel)(this.target.prototype, "memberModel");
-        (0, metadata_helpers_1.RequestTenantIdProperty)()(this.target.prototype, "tenantId");
+        metadata.applyAuthDecorators(this, pageInfo);
     }
 }
 exports.PageMetadata = PageMetadata;