@aglyn/aglyn 1.0.0-beta.217 → 1.0.0-beta.219

package/src/lib/plugin-manager/custom-fields.d.ts

@@ -25,8 +25,11 @@ import type { ComponentType } from 'react';
  * runs on BOTH sides (editor pre-save and the server import/write paths)
  * after the base-type validation.
  *
- * Register at module scope in a file imported by the plugin's client
- * barrel and /server entry (the AGL-428 config-schema pattern).
+ * Register the pure-data half (no `Input`) from the plugin's
+ * `serverDeclarations`, which every app runs at boot, so each server path
+ * that writes a record — the console's and the tenant's, including a public
+ * form and an automation step — validates it without loading the plugin's
+ * surfaces (AGL-2773). The client barrel registers it again with the Input.
  */
 /** Storage subset custom types may ride (mirrors Strapi's limitation). */
 export type CustomFieldBaseType = 'text' | 'bool' | 'int32' | 'float' | 'map';
@@ -58,3 +61,27 @@ export declare function listCustomFieldTypes(): CustomFieldType[];
  * guards storage), or empty optional values.
  */
 export declare function validateCustomFieldValue(customType: string | undefined, value: unknown): string | null;
+/** The custom type names a model's fields ride, in field order. */
+declare function customTypesOf(model: {
+    fields?: Record<string, {
+        customType?: string;
+    } | undefined>;
+    order?: readonly string[];
+} | null | undefined): string[];
+/**
+ * Makes sure every custom type a model names is registered before a record
+ * is validated against it (AGL-2773).
+ *
+ * `validateCustomFieldValue` answers "no error" for a type nobody registered.
+ * That is right for a plugin that is genuinely absent and wrong for one whose
+ * declarations did not run in this process, so a type the registry does not
+ * know runs the app's boot step once more (see `plugin-declarations-repair`)
+ * before the write validates. A model with no custom field, or whose types
+ * are all registered, costs nothing.
+ *
+ * Never throws: a failed repair leaves the base type guarding storage, which
+ * is what an absent plugin gets too, and the write it guards must not fail
+ * over it.
+ */
+export declare function ensureDeclaredCustomFieldTypes(model: Parameters<typeof customTypesOf>[0]): Promise<void>;
+export {};

package/src/lib/plugin-manager/custom-fields.js

@@ -13,7 +13,18 @@
  * 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.
- */ const customFieldTypes = new Map();
+ */ var _globalScope, _REGISTRY_KEY, _;
+import { runPluginDeclarationsRepair } from "./plugin-declarations-repair.js";
+/**
+ * The registry, held on `globalThis` rather than in a module `const`
+ * (AGL-3412, AGL-2773). A plugin's server declarations register its field
+ * types from the app's `instrumentation.ts`, which Next compiles into a
+ * different module graph from the routes that validate records, so a
+ * module-scoped map is filled in one copy and read as empty in the other —
+ * and an empty registry answers "no error" for every custom value.
+ */ const REGISTRY_KEY = Symbol.for('@aglyn/aglyn:custom-field-types');
+const globalScope = globalThis;
+const customFieldTypes = (_ = (_globalScope = globalScope)[_REGISTRY_KEY = REGISTRY_KEY]) != null ? _ : _globalScope[_REGISTRY_KEY] = new Map();
 /** Idempotent by name — re-registration replaces the type. */ export function registerCustomFieldType(fieldType) {
     customFieldTypes.set(fieldType.name, fieldType);
 }
@@ -35,5 +46,40 @@ export function listCustomFieldTypes() {
     if (value === undefined || value === null || value === '') return null;
     return fieldType.validate(value);
 }
+/** The custom type names a model's fields ride, in field order. */ function customTypesOf(model) {
+    var _ref;
+    const names = new Set();
+    for (const fieldId of (_ref = model == null ? void 0 : model.order) != null ? _ref : []){
+        var _model_fields_fieldId, _model_fields;
+        const customType = model == null ? void 0 : (_model_fields = model.fields) == null ? void 0 : (_model_fields_fieldId = _model_fields[fieldId]) == null ? void 0 : _model_fields_fieldId.customType;
+        if (customType) names.add(customType);
+    }
+    return [
+        ...names
+    ];
+}
+/**
+ * Makes sure every custom type a model names is registered before a record
+ * is validated against it (AGL-2773).
+ *
+ * `validateCustomFieldValue` answers "no error" for a type nobody registered.
+ * That is right for a plugin that is genuinely absent and wrong for one whose
+ * declarations did not run in this process, so a type the registry does not
+ * know runs the app's boot step once more (see `plugin-declarations-repair`)
+ * before the write validates. A model with no custom field, or whose types
+ * are all registered, costs nothing.
+ *
+ * Never throws: a failed repair leaves the base type guarding storage, which
+ * is what an absent plugin gets too, and the write it guards must not fail
+ * over it.
+ */ export async function ensureDeclaredCustomFieldTypes(model) {
+    const missing = customTypesOf(model).filter((name)=>!customFieldTypes.has(name));
+    if (!missing.length) return;
+    try {
+        await runPluginDeclarationsRepair();
+    } catch (error) {
+        console.error(`[custom-fields] plugin declarations failed before validating ${missing.join(', ')}`, error);
+    }
+}
 
 //# sourceMappingURL=custom-fields.js.map

package/src/lib/plugin-manager/custom-fields.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/plugin-manager/custom-fields.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { ComponentType } from 'react'\n\n/**\n * Custom field types (AGL-434, Strapi custom-fields parity): a plugin\n * declares a NAMED field type that rides an EXISTING dataset storage type\n * — no new storage primitives, so records stay portable and every query/\n * binding path keeps working. The dataset schema editor offers registered\n * types; a field using one stores `customType` next to its base `type`,\n * the record editor mounts the plugin's Input, and the custom `validate`\n * runs on BOTH sides (editor pre-save and the server import/write paths)\n * after the base-type validation.\n *\n * Register at module scope in a file imported by the plugin's client\n * barrel and /server entry (the AGL-428 config-schema pattern).\n */\n\n/** Storage subset custom types may ride (mirrors Strapi's limitation). */\nexport type CustomFieldBaseType = 'text' | 'bool' | 'int32' | 'float' | 'map'\n\nexport interface CustomFieldInputProps {\n  value: unknown\n  onChange: (value: unknown) => void\n  disabled?: boolean\n  label?: string\n}\n\nexport interface CustomFieldType {\n  /** Stable name persisted on field definitions ('rating'); never rename. */\n  name: string\n  pluginId: string\n  label: string\n  baseType: CustomFieldBaseType\n  description?: string\n  /** Record-editor input; base-type input is the fallback when absent. */\n  Input?: ComponentType<CustomFieldInputProps>\n  /** Runs after base-type validation; returns an error message or null. */\n  validate?: (value: unknown) => string | null\n}\n\nconst customFieldTypes = new Map<string, CustomFieldType>()\n\n/** Idempotent by name — re-registration replaces the type. */\nexport function registerCustomFieldType(fieldType: CustomFieldType): void {\n  customFieldTypes.set(fieldType.name, fieldType)\n}\n\nexport function getCustomFieldType(\n  name: string | undefined,\n): CustomFieldType | undefined {\n  return name ? customFieldTypes.get(name) : undefined\n}\n\nexport function listCustomFieldTypes(): CustomFieldType[] {\n  return [...customFieldTypes.values()]\n}\n\n/**\n * The custom-type validation hook (both sides): no-op for plain fields,\n * unknown custom types (plugin disabled/uninstalled — the base type still\n * guards storage), or empty optional values.\n */\nexport function validateCustomFieldValue(\n  customType: string | undefined,\n  value: unknown,\n): string | null {\n  const fieldType = getCustomFieldType(customType)\n  if (!fieldType?.validate) return null\n  if (value === undefined || value === null || value === '') return null\n  return fieldType.validate(value)\n}\n"],"names":["customFieldTypes","Map","registerCustomFieldType","fieldType","set","name","getCustomFieldType","get","undefined","listCustomFieldTypes","values","validateCustomFieldValue","customType","value","validate"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAyCD,MAAMA,mBAAmB,IAAIC;AAE7B,4DAA4D,GAC5D,OAAO,SAASC,wBAAwBC,SAA0B;IAChEH,iBAAiBI,GAAG,CAACD,UAAUE,IAAI,EAAEF;AACvC;AAEA,OAAO,SAASG,mBACdD,IAAwB;IAExB,OAAOA,OAAOL,iBAAiBO,GAAG,CAACF,QAAQG;AAC7C;AAEA,OAAO,SAASC;IACd,OAAO;WAAIT,iBAAiBU,MAAM;KAAG;AACvC;AAEA;;;;CAIC,GACD,OAAO,SAASC,yBACdC,UAA8B,EAC9BC,KAAc;IAEd,MAAMV,YAAYG,mBAAmBM;IACrC,IAAI,EAACT,6BAAAA,UAAWW,QAAQ,GAAE,OAAO;IACjC,IAAID,UAAUL,aAAaK,UAAU,QAAQA,UAAU,IAAI,OAAO;IAClE,OAAOV,UAAUW,QAAQ,CAACD;AAC5B"}
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/plugin-manager/custom-fields.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { ComponentType } from 'react'\nimport { runPluginDeclarationsRepair } from './plugin-declarations-repair'\n\n/**\n * Custom field types (AGL-434, Strapi custom-fields parity): a plugin\n * declares a NAMED field type that rides an EXISTING dataset storage type\n * — no new storage primitives, so records stay portable and every query/\n * binding path keeps working. The dataset schema editor offers registered\n * types; a field using one stores `customType` next to its base `type`,\n * the record editor mounts the plugin's Input, and the custom `validate`\n * runs on BOTH sides (editor pre-save and the server import/write paths)\n * after the base-type validation.\n *\n * Register the pure-data half (no `Input`) from the plugin's\n * `serverDeclarations`, which every app runs at boot, so each server path\n * that writes a record — the console's and the tenant's, including a public\n * form and an automation step — validates it without loading the plugin's\n * surfaces (AGL-2773). The client barrel registers it again with the Input.\n */\n\n/** Storage subset custom types may ride (mirrors Strapi's limitation). */\nexport type CustomFieldBaseType = 'text' | 'bool' | 'int32' | 'float' | 'map'\n\nexport interface CustomFieldInputProps {\n  value: unknown\n  onChange: (value: unknown) => void\n  disabled?: boolean\n  label?: string\n}\n\nexport interface CustomFieldType {\n  /** Stable name persisted on field definitions ('rating'); never rename. */\n  name: string\n  pluginId: string\n  label: string\n  baseType: CustomFieldBaseType\n  description?: string\n  /** Record-editor input; base-type input is the fallback when absent. */\n  Input?: ComponentType<CustomFieldInputProps>\n  /** Runs after base-type validation; returns an error message or null. */\n  validate?: (value: unknown) => string | null\n}\n\n/**\n * The registry, held on `globalThis` rather than in a module `const`\n * (AGL-3412, AGL-2773). A plugin's server declarations register its field\n * types from the app's `instrumentation.ts`, which Next compiles into a\n * different module graph from the routes that validate records, so a\n * module-scoped map is filled in one copy and read as empty in the other —\n * and an empty registry answers \"no error\" for every custom value.\n */\nconst REGISTRY_KEY = Symbol.for('@aglyn/aglyn:custom-field-types')\n\nconst globalScope = globalThis as typeof globalThis & {\n  [REGISTRY_KEY]?: Map<string, CustomFieldType>\n}\n\nconst customFieldTypes: Map<string, CustomFieldType> =\n  (globalScope[REGISTRY_KEY] ??= new Map<string, CustomFieldType>())\n\n/** Idempotent by name — re-registration replaces the type. */\nexport function registerCustomFieldType(fieldType: CustomFieldType): void {\n  customFieldTypes.set(fieldType.name, fieldType)\n}\n\nexport function getCustomFieldType(\n  name: string | undefined,\n): CustomFieldType | undefined {\n  return name ? customFieldTypes.get(name) : undefined\n}\n\nexport function listCustomFieldTypes(): CustomFieldType[] {\n  return [...customFieldTypes.values()]\n}\n\n/**\n * The custom-type validation hook (both sides): no-op for plain fields,\n * unknown custom types (plugin disabled/uninstalled — the base type still\n * guards storage), or empty optional values.\n */\nexport function validateCustomFieldValue(\n  customType: string | undefined,\n  value: unknown,\n): string | null {\n  const fieldType = getCustomFieldType(customType)\n  if (!fieldType?.validate) return null\n  if (value === undefined || value === null || value === '') return null\n  return fieldType.validate(value)\n}\n\n/** The custom type names a model's fields ride, in field order. */\nfunction customTypesOf(\n  model:\n    | {\n        fields?: Record<string, { customType?: string } | undefined>\n        order?: readonly string[]\n      }\n    | null\n    | undefined,\n): string[] {\n  const names = new Set<string>()\n  for (const fieldId of model?.order ?? []) {\n    const customType = model?.fields?.[fieldId]?.customType\n    if (customType) names.add(customType)\n  }\n  return [...names]\n}\n\n/**\n * Makes sure every custom type a model names is registered before a record\n * is validated against it (AGL-2773).\n *\n * `validateCustomFieldValue` answers \"no error\" for a type nobody registered.\n * That is right for a plugin that is genuinely absent and wrong for one whose\n * declarations did not run in this process, so a type the registry does not\n * know runs the app's boot step once more (see `plugin-declarations-repair`)\n * before the write validates. A model with no custom field, or whose types\n * are all registered, costs nothing.\n *\n * Never throws: a failed repair leaves the base type guarding storage, which\n * is what an absent plugin gets too, and the write it guards must not fail\n * over it.\n */\nexport async function ensureDeclaredCustomFieldTypes(\n  model: Parameters<typeof customTypesOf>[0],\n): Promise<void> {\n  const missing = customTypesOf(model).filter(\n    (name) => !customFieldTypes.has(name),\n  )\n  if (!missing.length) return\n  try {\n    await runPluginDeclarationsRepair()\n  } catch (error) {\n    console.error(\n      `[custom-fields] plugin declarations failed before validating ${missing.join(', ')}`,\n      error,\n    )\n  }\n}\n"],"names":["globalScope","REGISTRY_KEY","runPluginDeclarationsRepair","Symbol","for","globalThis","customFieldTypes","Map","registerCustomFieldType","fieldType","set","name","getCustomFieldType","get","undefined","listCustomFieldTypes","values","validateCustomFieldValue","customType","value","validate","customTypesOf","model","names","Set","fieldId","order","fields","add","ensureDeclaredCustomFieldTypes","missing","filter","has","length","error","console","join"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,OA4DEA,cAAYC,eAAZD;AAzDH,SAASE,2BAA2B,QAAQ,kCAA8B;AA0C1E;;;;;;;CAOC,GACD,MAAMD,eAAeE,OAAOC,GAAG,CAAC;AAEhC,MAAMJ,cAAcK;AAIpB,MAAMC,oBACHN,IAAAA,CAAAA,eAAAA,YAAW,CAACC,gBAAAA,aAAa,YAAzBD,IAAAA,YAAW,CAACC,cAAa,GAAK,IAAIM;AAErC,4DAA4D,GAC5D,OAAO,SAASC,wBAAwBC,SAA0B;IAChEH,iBAAiBI,GAAG,CAACD,UAAUE,IAAI,EAAEF;AACvC;AAEA,OAAO,SAASG,mBACdD,IAAwB;IAExB,OAAOA,OAAOL,iBAAiBO,GAAG,CAACF,QAAQG;AAC7C;AAEA,OAAO,SAASC;IACd,OAAO;WAAIT,iBAAiBU,MAAM;KAAG;AACvC;AAEA;;;;CAIC,GACD,OAAO,SAASC,yBACdC,UAA8B,EAC9BC,KAAc;IAEd,MAAMV,YAAYG,mBAAmBM;IACrC,IAAI,EAACT,6BAAAA,UAAWW,QAAQ,GAAE,OAAO;IACjC,IAAID,UAAUL,aAAaK,UAAU,QAAQA,UAAU,IAAI,OAAO;IAClE,OAAOV,UAAUW,QAAQ,CAACD;AAC5B;AAEA,iEAAiE,GACjE,SAASE,cACPC,KAMa;;IAEb,MAAMC,QAAQ,IAAIC;IAClB,KAAK,MAAMC,mBAAWH,yBAAAA,MAAOI,KAAK,mBAAI,EAAE,CAAE;YACrBJ,uBAAAA;QAAnB,MAAMJ,aAAaI,0BAAAA,gBAAAA,MAAOK,MAAM,sBAAbL,wBAAAA,aAAe,CAACG,QAAQ,qBAAxBH,sBAA0BJ,UAAU;QACvD,IAAIA,YAAYK,MAAMK,GAAG,CAACV;IAC5B;IACA,OAAO;WAAIK;KAAM;AACnB;AAEA;;;;;;;;;;;;;;CAcC,GACD,OAAO,eAAeM,+BACpBP,KAA0C;IAE1C,MAAMQ,UAAUT,cAAcC,OAAOS,MAAM,CACzC,CAACpB,OAAS,CAACL,iBAAiB0B,GAAG,CAACrB;IAElC,IAAI,CAACmB,QAAQG,MAAM,EAAE;IACrB,IAAI;QACF,MAAM/B;IACR,EAAE,OAAOgC,OAAO;QACdC,QAAQD,KAAK,CACX,CAAC,6DAA6D,EAAEJ,QAAQM,IAAI,CAAC,OAAO,EACpFF;IAEJ;AACF"}

package/src/lib/plugin-manager/feature-plugins.d.ts

@@ -15,14 +15,14 @@
  * limitations under the License.
  */
 import type { OrgPermissions } from '../app-utils/org-permissions';
+import type { SeoAuditReport } from '../app-utils/seo-audit';
 import type { SeoListingFieldKey } from '../app-utils/seo-listing-fields';
 import type { AglynOrgBilling, OrgFeatureFlags } from '../foundation';
 import type { ComponentSchema, MdiIconProps, PresetSchema } from '../types/nodes';
 import type { Plugin, PluginId } from './plugin-manager';
-import type { HostThemeSource } from '../app-utils/marketplace-theme';
+import type { HostThemeSource } from '../app-utils/site-theme';
 import type { HostTheme, HostThemeScheme } from '@aglyn/shared-data-types';
 import type { ComponentType } from 'react';
-export type { ConsoleProductCopyValues, ConsoleProductDraft, ConsoleProductEditorZoneProps, ConsoleProductImportZoneProps, ConsoleProductOption, ConsoleProductSummary, ConsoleProductType, ConsoleProductsHubZoneProps, ConsoleProposedDiscount, ConsoleProposedProduct, } from './commerce-zone-props';
 export type { ConsoleImportMappingZoneProps, ConsoleRecordEmailZoneProps, ConsoleRecordInsightsZoneProps, } from './record-zone-props';
 /** The mui bundle id every UI feature bundle depends on. */
 export declare const MUI_BUNDLE_ID: PluginId;
@@ -588,6 +588,69 @@ export declare const CONSOLE_WIDGET_SLOTS: {
      * marketplace.
      */
     readonly hostArtifactPublish: "hostArtifactPublish";
+    /**
+     * The org Plugins page, above the built-in plugins (AGL-3080): the code a
+     * plugin has INSTALLED into this workspace, one row per installation.
+     * Props: {@link ConsoleOrgPluginInstallsZoneProps}.
+     *
+     * The Plugins page is the workspace's inventory — what it runs, wherever it
+     * came from. The built-in half is the shell's own: the switchboard catalog
+     * says what ships. The installed half is not: where an installation is
+     * pinned, what version it runs, whether a newer one may be installed and
+     * whether its publisher's kill switch is thrown are all facts held by the
+     * plugin that installed it, in collections that are its own. So the page
+     * hands over the sites it can see and the plugin draws its installations.
+     *
+     * Every row links to `/[orgSlug]/plugins/[pluginRef]`, the shell's
+     * installation page, keyed by whatever id the installing plugin pins by —
+     * that page is the one place an installation is managed, whoever drew the
+     * row.
+     */
+    readonly orgPluginInstalls: "orgPluginInstalls";
+    /**
+     * The installation page of a plugin some plugin INSTALLED, above where it
+     * runs (AGL-3080): what the installer says about the version this
+     * workspace runs. Props: {@link ConsolePluginInstallStatusZoneProps}.
+     *
+     * Drawn only for an installation that exists — a first-party plugin has no
+     * version to be behind, and a page for code installed nowhere says so
+     * itself. A widget here reports; it never installs. Applying an update is
+     * the installing plugin's own surface, which the widget may link to.
+     */
+    readonly pluginInstallStatus: "pluginInstallStatus";
+    /**
+     * The template gallery — "Start from a template" on a site's Screens,
+     * Layouts and Components pages — below the site's own templates and the
+     * starters (AGL-3080): a shelf of templates a plugin offers to INSTALL.
+     * Props: {@link ConsoleTemplateGalleryZoneProps}.
+     *
+     * The gallery is the shell's: what the site holds and what ships with the
+     * platform. Templates offered from elsewhere are the offering plugin's —
+     * what it lists, how it is searched, what it costs and the route that
+     * installs one, with every check that route makes — so the dialog hands
+     * over the kind it picks and the word typed in its search, and the plugin
+     * draws its own shelf. An install lands in the site's library and
+     * publishes nothing; the widget calls `onInstalled` so the gallery closes.
+     *
+     * The dialog's "nothing matches" line covers every shelf, so a widget
+     * reports whether its shelf is loading, empty or showing something through
+     * `reportShelf`. A widget that never reports is a shelf the line ignores;
+     * with no widget at all the gallery is the site's own and the starters.
+     */
+    readonly templateGallery: "templateGallery";
+    /**
+     * One row of a site's Templates library whose template a plugin INSTALLED,
+     * beside its Source badge (AGL-3080): what the installer says about the
+     * copy the site holds — that a newer version can be installed, and the
+     * control that installs it. Props: {@link ConsoleTemplateInstallStatusZoneProps}.
+     *
+     * Drawn once per such row, and never for a template saved here or a
+     * starter. A widget draws nothing for a template it did not install, and
+     * nothing when there is nothing to say. Applying an update goes through
+     * the installing plugin's own route, which keeps all its checks; the
+     * library's rows re-read the templates it replaced.
+     */
+    readonly templateInstallStatus: "templateInstallStatus";
     /** Bottom of the host dashboard. Props: hostId, org. (AGL-433) */
     readonly dashboardFooter: "dashboardFooter";
     /** Org settings page, below the tabbed cards. Props: orgId, org. */
@@ -642,6 +705,13 @@ export declare const CONSOLE_WIDGET_SLOTS: {
      * widget.
      */
     readonly hostTheme: "hostTheme";
+    /**
+     * The staff overview, among its platform-wide cards (AGL-3080). No props:
+     * the overview is about the platform, not one org, so a widget here reads
+     * what its plugin holds across every workspace through its own staff
+     * route. A staff zone — see {@link CONSOLE_STAFF_WIDGET_SLOTS}.
+     */
+    readonly staffOverview: "staffOverview";
     /**
      * Staff admin org detail (staff-only surfaces). Props: orgId. A staff
      * zone — see {@link CONSOLE_STAFF_WIDGET_SLOTS}.
@@ -723,12 +793,13 @@ export declare const CONSOLE_WIDGET_SLOTS: {
      */
     readonly hostMembers: "hostMembers";
     /**
-     * The console shell's assistant dock (AGL-2940): the one position above
-     * every route boundary in both the `(app)` and `(editor)` shells, where a
-     * floating helper survives a navigation. Props: none — a widget here
-     * resolves its own scope from the URL, as the shell's own chrome does.
+     * The console dock (AGL-2940): the one position above every route boundary
+     * in both the `(app)` and `(editor)` shells, where a floating panel — an
+     * assistant, a helper — survives a navigation. Props:
+     * {@link ConsoleDockZoneProps}. Named for the position, not for what a
+     * plugin puts there (AGL-3080: it was `assistPanel`).
      */
-    readonly assistPanel: "assistPanel";
+    readonly consoleDock: "consoleDock";
     /**
      * A section at the bottom of the besigner's Attributes panel (AGL-2940),
      * under the selected element's own fields. Props: `hostId` (`null` on an
@@ -751,11 +822,11 @@ export declare const CONSOLE_WIDGET_SLOTS: {
      */
     readonly seoFields: "seoFields";
     /**
-     * The host setup SEO section, above the site SEO form (AGL-2910). Props:
-     * {@link ConsoleHostSeoZoneProps} — the site, its stored SEO settings, and
-     * `proposeDraft`, which puts values in the form as unsaved edits. The
-     * form's Update stores them; nothing a widget proposes reaches the
-     * published site before that.
+     * The host setup SEO section, under the site's SEO check and above the site
+     * SEO form (AGL-2910). Props: {@link ConsoleHostSeoZoneProps} — the site,
+     * its stored SEO settings, the check's last report, and `proposeDraft`,
+     * which puts values in the form as unsaved edits. The form's Update stores
+     * them; nothing a widget proposes reaches the published site before that.
      */
     readonly hostSeo: "hostSeo";
     /** {@link ConsoleRecordInsightsZoneProps} */
@@ -852,12 +923,6 @@ export declare const CONSOLE_WIDGET_SLOTS: {
      * changes nothing.
      */
     readonly automationRun: "automationRun";
-    /** The commerce product editor's fields (AGL-2916). Props: {@link ConsoleProductEditorZoneProps}. */
-    readonly productEditor: "productEditor";
-    /** Above the commerce products hub's catalog table (AGL-2916). Props: {@link ConsoleProductsHubZoneProps}. */
-    readonly productsHub: "productsHub";
-    /** Inside the commerce CSV import dialog (AGL-2916). Props: {@link ConsoleProductImportZoneProps}. */
-    readonly productImport: "productImport";
 };
 export type ConsoleWidgetSlot = (typeof CONSOLE_WIDGET_SLOTS)[keyof typeof CONSOLE_WIDGET_SLOTS];
 /** What the `hostScreens` zone hands each widget (AGL-2907). */
@@ -975,6 +1040,108 @@ export interface ConsolePublishableArtifact {
     displayName?: string;
     description?: string;
 }
+/** One site of the workspace, as the console names it. */
+export interface ConsoleZoneSite {
+    id: string;
+    label: string;
+}
+/** What the `orgPluginInstalls` zone hands each widget (AGL-3080). */
+export interface ConsoleOrgPluginInstallsZoneProps {
+    /** The organization whose inventory the page is. */
+    orgId: string;
+    /** Path slug for building `/[orgSlug]/…` links. */
+    orgSlug: string;
+    /**
+     * The sites of the organization the reader can see. An installation may be
+     * pinned to some of them rather than to the whole organization, so a widget
+     * reads each site's pins through this list rather than listing sites
+     * itself.
+     */
+    hosts: ReadonlyArray<ConsoleZoneSite>;
+}
+/** What the `pluginInstallStatus` zone hands each widget (AGL-3080). */
+export interface ConsolePluginInstallStatusZoneProps {
+    /** Path slug for building `/[orgSlug]/…` links. */
+    orgSlug: string;
+    /** The installation's id: the segment of the page, which is the pin's key. */
+    pluginRef: string;
+    /**
+     * One pin of the installation — org-wide if there is one, else any site's.
+     * Every pin carries the same version and manifest, which is what a status
+     * is about.
+     */
+    pin: Readonly<Record<string, unknown>>;
+}
+/** A release flag's verdict as the console applies it: the staff bypass included. */
+export interface ConsoleReleaseVerdict {
+    /** Released, or the reader is staff. */
+    visible: boolean;
+    /** Visible ONLY because the reader is staff. */
+    staffPreview: boolean;
+}
+/** What the `consoleDock` zone hands each widget (AGL-2940, AGL-3080). */
+export interface ConsoleDockZoneProps {
+    orgId?: string;
+    org?: unknown;
+    orgReady: boolean;
+    /**
+     * The org a widget may speak for, act as, and be METERED against — or
+     * `undefined` where the page named none, or where the membership positively
+     * contradicts the URL (AGL-1130, AGL-1916, AGL-1934).
+     */
+    scopedOrgId?: string;
+    /** Path slug for building `/[orgSlug]/…` links. */
+    orgSlug: string;
+    /** The site in view, or null off a host route. */
+    hostId: string | null;
+    /** The product's name as this org reads it (AGL-2319). */
+    productName: string;
+    /**
+     * The verdict for any release flag the widget names, staff bypass applied.
+     * The shell names no plugin's flag; a widget asks for its own.
+     */
+    releaseVerdict: (key: string) => ConsoleReleaseVerdict;
+    isStaff: boolean;
+    /** The reader's verdict for every declared permission key on the site in view. */
+    permissionsOnHost?: {
+        loaded: boolean;
+        granted: Readonly<Record<string, boolean>>;
+    };
+}
+/** How one plugin's shelf of the template gallery stands (AGL-3080). */
+export type ConsoleTemplateGalleryShelfState = 'loading' | 'empty' | 'shown';
+/** What the `templateGallery` zone hands each widget (AGL-3080). */
+export interface ConsoleTemplateGalleryZoneProps {
+    /** The site a template installs into. */
+    hostId: string;
+    /**
+     * The kind of template the gallery picks: `page` on the Screens page,
+     * `layout` and `component` on theirs. A shelf offering only one kind
+     * draws nothing for the others.
+     */
+    kind: 'page' | 'component' | 'layout';
+    /** The word typed in the gallery's search box, `''` for none. */
+    search: string;
+    /** Closes the gallery once an install has landed in the library. */
+    onInstalled: () => void;
+    /**
+     * Says how this shelf stands, keyed by a name the widget chooses and keeps,
+     * so the gallery's "nothing matches" line counts it. Report `empty` rather
+     * than nothing once a read answers with nothing.
+     */
+    reportShelf: (shelfId: string, state: ConsoleTemplateGalleryShelfState) => void;
+}
+/** What the `templateInstallStatus` zone hands each widget (AGL-3080). */
+export interface ConsoleTemplateInstallStatusZoneProps {
+    /** The site whose library the row is in. */
+    hostId: string;
+    /**
+     * The row's template document as the library read it, `$id` included:
+     * its server-managed `source` and `installedFrom` stamps say who installed
+     * it, and `editedAt` whether the site has edited its copy since.
+     */
+    template: Readonly<Record<string, unknown>>;
+}
 /** What the `hostArtifactPublish` zone hands each widget (AGL-3080). */
 export interface ConsoleArtifactPublishZoneProps {
     /**
@@ -1012,8 +1179,8 @@ export interface ConsoleHostThemeZoneProps {
     proposeDraft: (theme: HostTheme, key: string) => void;
 }
 /**
- * The zones on the STAFF pages (AGL-2939): the staff org page, its detail
- * zone, and the staff user page.
+ * The zones on the STAFF pages (AGL-2939): the staff overview, the staff org
+ * page, its detail zone, and the staff user page.
  *
  * No workspace names the plugin set there. A staff page is ABOUT an org or
  * an account, and the reader's own memberships have nothing to do with what
@@ -1073,6 +1240,16 @@ export interface ConsoleSeoFieldsZoneProps {
      */
     proposeValues: (values: ConsoleSeoFieldValues, key: string) => void;
 }
+/**
+ * The site's SEO check as the SEO section last ran it: the platform's
+ * findings (`app-utils/seo-audit`), which the section draws for every site
+ * owner, and the target keyword lines the check was run with.
+ */
+export interface ConsoleSeoCheck {
+    report: SeoAuditReport;
+    /** The keyword lines as typed, one page a line: `/pricing: plans, pricing`. */
+    keywords: string;
+}
 /** What the `hostSeo` zone hands each widget (AGL-2910). */
 export interface ConsoleHostSeoZoneProps {
     hostId: string;
@@ -1091,6 +1268,12 @@ export interface ConsoleHostSeoZoneProps {
      * applies once, and the form's Update is what stores them.
      */
     proposeDraft: (values: Record<string, string>, key: string) => void;
+    /**
+     * The SEO check the section drew above the zone, once somebody has run it
+     * this visit; `null` before. The section lists the findings: a widget adds
+     * what it has for them — a proposed fix, say — and never lists them again.
+     */
+    check: ConsoleSeoCheck | null;
 }
 /**
  * A column a widget contributes to a shell-owned table (AGL-2940) — the org
@@ -1432,6 +1615,13 @@ export interface ConsoleExtension {
      * `console.slots`.
      */
     themePresets?: readonly ConsoleThemePreset[];
+    /**
+     * The kinds of record this plugin lets the console's search find — see
+     * {@link ConsoleSearchSource}. Loaded with the plugin at the
+     * {@link CONSOLE_SEARCH_LOAD_POINT}, which the plugin declares among its
+     * `console.slots`.
+     */
+    searchSources?: readonly ConsoleSearchSource[];
     /**
      * Pages in the STAFF area (AGL-2939) — see {@link ConsoleStaffPage}.
      * Neither `featureFlag` nor `permission` applies to them.
@@ -1604,5 +1794,87 @@ export declare const THEME_PRESETS_LOAD_POINT = "hostThemePresets";
 export declare function listConsoleThemePresets(enabledPluginIds?: readonly PluginId[]): Array<ConsoleThemePreset & {
     pluginId: PluginId;
 }>;
+/**
+ * A kind of record a plugin lets the console's search find (AGL-3080): the
+ * collection its rows are read from, the fields a row is named and matched
+ * by, and where a row opens.
+ *
+ * The palette reads a source the way it reads the console's own groups — one
+ * capped window per collection, ordered by document id and matched in the
+ * browser — so a source describes a read the Firestore rules already admit
+ * and needs no index of its own. `host` reads `hosts/{hostId}/{collection}`
+ * under the site that is open; `orgData` reads `orgs/{orgId}/{collection}`,
+ * the organization's shared data, through the reader's `visibleTo` tokens
+ * under a site (the predicate the rules evaluate) and unfiltered at the
+ * organization level, where only an org-wide member is offered it.
+ *
+ * Gated as every surface the extension registers is: the plugin must be on
+ * for the workspace and the site, and the extension's `featureFlag` and
+ * `permission` compose with the source's own. A source the reader may not
+ * open is never read, because a row that links to a page the reader is
+ * refused is a dead row.
+ */
+export interface ConsoleSearchSource {
+    /**
+     * The group's id, unique across the palette: its rows, its cache and its
+     * key in the rendered list are held under it. Name it by the plugin's own
+     * words (`contacts`, `products`) and keep it stable.
+     */
+    id: string;
+    /** The heading above the group's rows. */
+    group: string;
+    /** The kind in a sentence: "Only the first 30 {noun} were searched." */
+    noun: string;
+    /** Where the collection hangs, which decides the path and who may read it. */
+    scope: 'host' | 'orgData';
+    /** The collection's name under the scope's root. */
+    collection: string;
+    /** The field holding a row's human-readable name. */
+    nameField: string;
+    /** The field a row is labeled by when `nameField` is empty. */
+    fallbackNameField?: string;
+    /** Further fields a reader may find a row by (an address, a slug). */
+    extraFields?: readonly string[];
+    /**
+     * A plan quota that must be non-zero for the group to be read at all: a
+     * collection the organization cannot hold costs a read to render nothing.
+     */
+    entitlementKey?: string;
+    /** A plan flag this group needs beyond the extension's `featureFlag`. */
+    featureFlag?: keyof OrgFeatureFlags;
+    /** A permission this group needs beyond the extension's `permission`. */
+    permission?: string;
+    /**
+     * Where the group is listed, ascending. The console's own groups hold 10
+     * (sites), 20 (pages), 30 (emails) and 100 to 140 (components, layouts,
+     * templates, content, authors); equal numbers keep registration order.
+     */
+    order: number;
+    /**
+     * Where one row opens, or `null` when it cannot be addressed from here — a
+     * row with nowhere to go is dropped rather than drawn dead. `host` is the
+     * open site's subdomain, or `null` at the organization level.
+     */
+    href(row: Readonly<Record<string, unknown>>, context: ConsoleSearchLinkContext): string | null;
+}
+/** The two route params a search row is linked from. */
+export interface ConsoleSearchLinkContext {
+    orgSlug: string;
+    host: string | null;
+}
+/**
+ * The load point a plugin contributing search sources declares in its
+ * `console.slots`, and the palette loads before it lists them.
+ */
+export declare const CONSOLE_SEARCH_LOAD_POINT = "consoleSearch";
+/**
+ * Every search source the enabled plugins contribute, with the extension
+ * each came from so the caller can apply its gates. A second source with an
+ * id already listed is dropped, so two plugins cannot share one group.
+ */
+export declare function listConsoleSearchSources(enabledPluginIds?: readonly PluginId[]): Array<{
+    extension: ConsoleExtension;
+    source: ConsoleSearchSource;
+}>;
 /** Providers registered by every extension, in registration order. */
 export declare function listConsoleProviders(enabledPluginIds?: readonly PluginId[]): Array<ComponentType<any>>;