@aglyn/aglyn 1.0.0-beta.220 → 1.0.0-beta.222

package/src/lib/plugin-manager/interaction-recipes.js

@@ -0,0 +1,104 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * 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.
+ */ var _globalScope_RECIPES_KEY;
+import { getRegisteringPluginId } from "../app-utils/registering-plugin.js";
+import { PLUGIN_INTERACTION_RECIPES_DECLARED } from "./first-party-plugins.generated.js";
+/** Every recipe a first-party plugin declares, in `plugins.config.json` order. */ export function declaredInteractionRecipes() {
+    return PLUGIN_INTERACTION_RECIPES_DECLARED;
+}
+/**
+ * One table per process, on `globalThis` (AGL-3412): the server apps register
+ * from `instrumentation.ts`, which Next compiles apart from the routes that
+ * read, and a module-scoped map would be filled in one copy and read empty in
+ * the other.
+ */ const RECIPES_KEY = Symbol.for('@aglyn/aglyn:interaction-recipes');
+const globalScope = globalThis;
+const recipes = (_globalScope_RECIPES_KEY = globalScope[RECIPES_KEY]) != null ? _globalScope_RECIPES_KEY : globalScope[RECIPES_KEY] = new Map();
+/**
+ * Registers a plugin's recipes, in the order its menu lists them.
+ *
+ * The owner is the plugin whose register fn is running, or the `pluginId`
+ * passed for a boot declaration. A registration with neither is refused; so is
+ * a recipe id another plugin declares or already registered, because two
+ * recipes under one id would each answer for the other's stamps. The same
+ * plugin registering again replaces its own. Nothing is registered unless
+ * every recipe is accepted.
+ */ export function registerInteractionRecipes(list, options) {
+    var _ref, _getRegisteringPluginId;
+    const pluginId = ((_ref = (_getRegisteringPluginId = getRegisteringPluginId()) != null ? _getRegisteringPluginId : options == null ? void 0 : options.pluginId) != null ? _ref : '').trim();
+    if (!pluginId) {
+        throw new Error('interaction recipes were registered with no owner: pass { pluginId } ' + 'when registering outside a plugin register fn');
+    }
+    for (const recipe of list){
+        const id = recipe.id.trim();
+        if (!id) throw new Error(`"${pluginId}" registered an interaction recipe with no id`);
+        const declared = PLUGIN_INTERACTION_RECIPES_DECLARED.find((row)=>row.id === id);
+        if (declared && declared.pluginId !== pluginId) {
+            throw new Error(`interaction recipe "${id}" is declared by "${declared.pluginId}"; refused "${pluginId}"`);
+        }
+        const held = recipes.get(id);
+        if (held && held.pluginId !== pluginId) {
+            throw new Error(`interaction recipe "${id}" is already registered by "${held.pluginId}"; refused "${pluginId}"`);
+        }
+    }
+    for (const [id, entry] of [
+        ...recipes
+    ])if (entry.pluginId === pluginId) recipes.delete(id);
+    for (const recipe of list)recipes.set(recipe.id.trim(), {
+        pluginId,
+        recipe
+    });
+}
+/** Every registered recipe, each plugin's in its own order. */ export function interactionRecipes() {
+    return [
+        ...recipes.values()
+    ].map((entry)=>entry.recipe);
+}
+/** The registered recipe with this id, or `null` for one nobody registered. */ export function interactionRecipe(id) {
+    var _ref;
+    var _recipes_get;
+    return typeof id === 'string' ? (_ref = (_recipes_get = recipes.get(id)) == null ? void 0 : _recipes_get.recipe) != null ? _ref : null : null;
+}
+/**
+ * Whether a stamp names a recipe: one a first-party plugin declares, or one a
+ * plugin registered in this process.
+ */ export function isKnownInteractionRecipe(id) {
+    if (typeof id !== 'string' || !id) return false;
+    return recipes.has(id) || PLUGIN_INTERACTION_RECIPES_DECLARED.some((row)=>row.id === id);
+}
+/**
+ * The recipe a STORED interaction came from, read off its document (AGL-2639).
+ *
+ * Three answers, and the third is the one that matters. A known id: the
+ * interaction was installed from, or begun as, that recipe — one a plugin
+ * declares or registered ({@link isKnownInteractionRecipe}). `null`: it was
+ * begun blank, or from a recipe this build no longer knows — the editor wrote
+ * the field and said "no recipe". `undefined`: the document carries no
+ * `recipe` field at all, which is every interaction saved before the stamp
+ * existed. Such an interaction may well have started from a recipe — the menu
+ * opened the editor prefilled long before anything recorded it — so a reader
+ * that needs to know whether a site has a recipe treats `undefined` as
+ * UNKNOWN, never as absent, and never writes a `null` over it.
+ */ export function interactionRecipeStamp(interaction) {
+    const stamp = interaction == null ? void 0 : interaction.recipe;
+    if (stamp === undefined) return undefined;
+    return isKnownInteractionRecipe(stamp) ? stamp : null;
+}
+/** Only for specs: forgets every registered recipe. */ export function resetInteractionRecipesForTests() {
+    recipes.clear();
+}
+
+//# sourceMappingURL=interaction-recipes.js.map

package/src/lib/plugin-manager/interaction-recipes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/plugin-manager/interaction-recipes.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 { InteractionStepBase, SiteInteraction } from '../app-utils/site-interactions'\nimport { getRegisteringPluginId } from '../app-utils/registering-plugin'\nimport { PLUGIN_INTERACTION_RECIPES_DECLARED } from './first-party-plugins.generated'\n\n/**\n * A READY-TO-EDIT INTERACTION ANOTHER PLUGIN OFFERS (AGL-3080).\n *\n * A recipe is a stored interaction — a trigger, its conditions and an ordered\n * step list — built from the step vocabulary and handed to an editor as a\n * draft. Nothing is written until a person saves, and every field is theirs to\n * change first: the recipe decides where the editor starts, not what the site\n * runs. The plugin that knows what a recipe is FOR writes it — the CRM's\n * \"Welcome a new lead\" is the CRM's — and the plugin that edits and stores\n * interactions offers it. Neither imports the other: the author registers its\n * recipes here, and the editor reads them.\n *\n * A stored interaction remembers the recipe it began as by the recipe's id\n * (its `recipe` stamp), so a recipe's id never changes once it has shipped.\n *\n * ## Declared, then registered\n *\n * A recipe BUILDS its interaction, which is code, so it is registered — from\n * the author's `declarations` entry, which both apps and the console's loader\n * run at boot. Its ID is also declared, under `interactionRecipes` in\n * `plugins.config.json`, and compiled into core, because a validator must know\n * a stamp names a real recipe in every process, including one where the\n * author's declarations did not run: {@link isKnownInteractionRecipe} answers\n * from either. A marketplace plugin's recipes are registered and never\n * compiled, and are known once registered.\n */\n\n/** The compiled declaration: which plugin offers which recipe. */\nexport interface InteractionRecipeDeclaration {\n  pluginId: string\n  /** The recipe's id, as a stored interaction's `recipe` stamp names it. */\n  id: string\n}\n\n/** What a recipe is handed before it builds. */\nexport interface InteractionRecipeInput {\n  /** The record a person picked, for a recipe that {@link InteractionRecipe.picks} one. */\n  picked?: { id: string; name: string }\n}\n\n/**\n * The record a person picks before a recipe can be built, and the words the\n * editor asks for it in. The editor lists the records of `kind` through the\n * list source the plugin that keeps them publishes (`plugin-record-lists`).\n */\nexport interface InteractionRecipePick {\n  /** The record kind, as `plugin-record-lists` lists it: `'form'`. */\n  kind: string\n  /** The picker's label: \"Form\". */\n  label: string\n  /** The kind's plural, for the sentence that says the list was cut short: \"forms\". */\n  plural: string\n  /** What the person is asked to pick, one sentence: \"Pick the form whose new contacts get the tag.\" */\n  prompt: string\n  /** What the picker says on a site that has none. */\n  none: string\n}\n\n/** The interaction a recipe builds: a fresh one each call, stamped with the recipe's id. */\nexport type InteractionRecipeDraft = SiteInteraction<InteractionStepBase> & {\n  recipe: string\n}\n\nexport interface InteractionRecipe {\n  /** Never changes once shipped: stored interactions name it. */\n  id: string\n  /** How the recipe reads in a menu; also the interaction's starting name. */\n  title: string\n  /** One sentence under the title. */\n  description: string\n  /**\n   * The record a person picks before the recipe can be built. A recipe that\n   * needs nothing opens the editor at once. Built WITHOUT its pick, such a\n   * recipe yields an interaction a validator refuses — a condition with no\n   * value — rather than one that saves and then silently matches nothing.\n   */\n  picks?: InteractionRecipePick\n  /**\n   * A fresh interaction each call, because the draft is edited in place. It\n   * carries `recipe: id` — the provenance is the builder's to stamp, so a\n   * writer that saves what it was handed cannot forget it.\n   */\n  build(input?: InteractionRecipeInput): InteractionRecipeDraft\n}\n\n/** Every recipe a first-party plugin declares, in `plugins.config.json` order. */\nexport function declaredInteractionRecipes(): readonly InteractionRecipeDeclaration[] {\n  return PLUGIN_INTERACTION_RECIPES_DECLARED\n}\n\ninterface RegisteredRecipe {\n  pluginId: string\n  recipe: InteractionRecipe\n}\n\n/**\n * One table per process, on `globalThis` (AGL-3412): the server apps register\n * from `instrumentation.ts`, which Next compiles apart from the routes that\n * read, and a module-scoped map would be filled in one copy and read empty in\n * the other.\n */\nconst RECIPES_KEY = Symbol.for('@aglyn/aglyn:interaction-recipes')\n\nconst globalScope = globalThis as typeof globalThis & {\n  [RECIPES_KEY]?: Map<string, RegisteredRecipe>\n}\n\nconst recipes: Map<string, RegisteredRecipe> =\n  globalScope[RECIPES_KEY] ?? (globalScope[RECIPES_KEY] = new Map())\n\n/**\n * Registers a plugin's recipes, in the order its menu lists them.\n *\n * The owner is the plugin whose register fn is running, or the `pluginId`\n * passed for a boot declaration. A registration with neither is refused; so is\n * a recipe id another plugin declares or already registered, because two\n * recipes under one id would each answer for the other's stamps. The same\n * plugin registering again replaces its own. Nothing is registered unless\n * every recipe is accepted.\n */\nexport function registerInteractionRecipes(\n  list: readonly InteractionRecipe[],\n  options?: { pluginId?: string },\n): void {\n  const pluginId = (getRegisteringPluginId() ?? options?.pluginId ?? '').trim()\n  if (!pluginId) {\n    throw new Error(\n      'interaction recipes were registered with no owner: pass { pluginId } ' +\n        'when registering outside a plugin register fn',\n    )\n  }\n  for (const recipe of list) {\n    const id = recipe.id.trim()\n    if (!id) throw new Error(`\"${pluginId}\" registered an interaction recipe with no id`)\n    const declared = PLUGIN_INTERACTION_RECIPES_DECLARED.find((row) => row.id === id)\n    if (declared && declared.pluginId !== pluginId) {\n      throw new Error(\n        `interaction recipe \"${id}\" is declared by \"${declared.pluginId}\"; refused \"${pluginId}\"`,\n      )\n    }\n    const held = recipes.get(id)\n    if (held && held.pluginId !== pluginId) {\n      throw new Error(\n        `interaction recipe \"${id}\" is already registered by \"${held.pluginId}\"; refused \"${pluginId}\"`,\n      )\n    }\n  }\n  for (const [id, entry] of [...recipes]) if (entry.pluginId === pluginId) recipes.delete(id)\n  for (const recipe of list) recipes.set(recipe.id.trim(), { pluginId, recipe })\n}\n\n/** Every registered recipe, each plugin's in its own order. */\nexport function interactionRecipes(): InteractionRecipe[] {\n  return [...recipes.values()].map((entry) => entry.recipe)\n}\n\n/** The registered recipe with this id, or `null` for one nobody registered. */\nexport function interactionRecipe(id: unknown): InteractionRecipe | null {\n  return typeof id === 'string' ? (recipes.get(id)?.recipe ?? null) : null\n}\n\n/**\n * Whether a stamp names a recipe: one a first-party plugin declares, or one a\n * plugin registered in this process.\n */\nexport function isKnownInteractionRecipe(id: unknown): id is string {\n  if (typeof id !== 'string' || !id) return false\n  return recipes.has(id) || PLUGIN_INTERACTION_RECIPES_DECLARED.some((row) => row.id === id)\n}\n\n/**\n * The recipe a STORED interaction came from, read off its document (AGL-2639).\n *\n * Three answers, and the third is the one that matters. A known id: the\n * interaction was installed from, or begun as, that recipe — one a plugin\n * declares or registered ({@link isKnownInteractionRecipe}). `null`: it was\n * begun blank, or from a recipe this build no longer knows — the editor wrote\n * the field and said \"no recipe\". `undefined`: the document carries no\n * `recipe` field at all, which is every interaction saved before the stamp\n * existed. Such an interaction may well have started from a recipe — the menu\n * opened the editor prefilled long before anything recorded it — so a reader\n * that needs to know whether a site has a recipe treats `undefined` as\n * UNKNOWN, never as absent, and never writes a `null` over it.\n */\nexport function interactionRecipeStamp(\n  interaction: { recipe?: unknown } | null | undefined,\n): string | null | undefined {\n  const stamp = interaction?.recipe\n  if (stamp === undefined) return undefined\n  return isKnownInteractionRecipe(stamp) ? stamp : null\n}\n\n/** Only for specs: forgets every registered recipe. */\nexport function resetInteractionRecipesForTests(): void {\n  recipes.clear()\n}\n"],"names":["globalScope","getRegisteringPluginId","PLUGIN_INTERACTION_RECIPES_DECLARED","declaredInteractionRecipes","RECIPES_KEY","Symbol","for","globalThis","recipes","Map","registerInteractionRecipes","list","options","pluginId","trim","Error","recipe","id","declared","find","row","held","get","entry","delete","set","interactionRecipes","values","map","interactionRecipe","isKnownInteractionRecipe","has","some","interactionRecipeStamp","interaction","stamp","undefined","resetInteractionRecipesForTests","clear"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,OAkHCA;AA/GF,SAASC,sBAAsB,QAAQ,qCAAiC;AACxE,SAASC,mCAAmC,QAAQ,qCAAiC;AAuFrF,gFAAgF,GAChF,OAAO,SAASC;IACd,OAAOD;AACT;AAOA;;;;;CAKC,GACD,MAAME,cAAcC,OAAOC,GAAG,CAAC;AAE/B,MAAMN,cAAcO;AAIpB,MAAMC,WACJR,2BAAAA,WAAW,CAACI,YAAY,YAAxBJ,2BAA6BA,WAAW,CAACI,YAAY,GAAG,IAAIK;AAE9D;;;;;;;;;CASC,GACD,OAAO,SAASC,2BACdC,IAAkC,EAClCC,OAA+B;QAEbX,MAAAA;IAAlB,MAAMY,WAAW,EAACZ,QAAAA,0BAAAA,oCAAAA,0BAA4BW,2BAAAA,QAASC,QAAQ,YAA7CZ,OAAiD,IAAIa,IAAI;IAC3E,IAAI,CAACD,UAAU;QACb,MAAM,IAAIE,MACR,0EACE;IAEN;IACA,KAAK,MAAMC,UAAUL,KAAM;QACzB,MAAMM,KAAKD,OAAOC,EAAE,CAACH,IAAI;QACzB,IAAI,CAACG,IAAI,MAAM,IAAIF,MAAM,CAAC,CAAC,EAAEF,SAAS,6CAA6C,CAAC;QACpF,MAAMK,WAAWhB,oCAAoCiB,IAAI,CAAC,CAACC,MAAQA,IAAIH,EAAE,KAAKA;QAC9E,IAAIC,YAAYA,SAASL,QAAQ,KAAKA,UAAU;YAC9C,MAAM,IAAIE,MACR,CAAC,oBAAoB,EAAEE,GAAG,kBAAkB,EAAEC,SAASL,QAAQ,CAAC,YAAY,EAAEA,SAAS,CAAC,CAAC;QAE7F;QACA,MAAMQ,OAAOb,QAAQc,GAAG,CAACL;QACzB,IAAII,QAAQA,KAAKR,QAAQ,KAAKA,UAAU;YACtC,MAAM,IAAIE,MACR,CAAC,oBAAoB,EAAEE,GAAG,4BAA4B,EAAEI,KAAKR,QAAQ,CAAC,YAAY,EAAEA,SAAS,CAAC,CAAC;QAEnG;IACF;IACA,KAAK,MAAM,CAACI,IAAIM,MAAM,IAAI;WAAIf;KAAQ,CAAE,IAAIe,MAAMV,QAAQ,KAAKA,UAAUL,QAAQgB,MAAM,CAACP;IACxF,KAAK,MAAMD,UAAUL,KAAMH,QAAQiB,GAAG,CAACT,OAAOC,EAAE,CAACH,IAAI,IAAI;QAAED;QAAUG;IAAO;AAC9E;AAEA,6DAA6D,GAC7D,OAAO,SAASU;IACd,OAAO;WAAIlB,QAAQmB,MAAM;KAAG,CAACC,GAAG,CAAC,CAACL,QAAUA,MAAMP,MAAM;AAC1D;AAEA,6EAA6E,GAC7E,OAAO,SAASa,kBAAkBZ,EAAW;;QACVT;IAAjC,OAAO,OAAOS,OAAO,oBAAYT,eAAAA,QAAQc,GAAG,CAACL,wBAAZT,aAAiBQ,MAAM,mBAAI,OAAQ;AACtE;AAEA;;;CAGC,GACD,OAAO,SAASc,yBAAyBb,EAAW;IAClD,IAAI,OAAOA,OAAO,YAAY,CAACA,IAAI,OAAO;IAC1C,OAAOT,QAAQuB,GAAG,CAACd,OAAOf,oCAAoC8B,IAAI,CAAC,CAACZ,MAAQA,IAAIH,EAAE,KAAKA;AACzF;AAEA;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASgB,uBACdC,WAAoD;IAEpD,MAAMC,QAAQD,+BAAAA,YAAalB,MAAM;IACjC,IAAImB,UAAUC,WAAW,OAAOA;IAChC,OAAON,yBAAyBK,SAASA,QAAQ;AACnD;AAEA,qDAAqD,GACrD,OAAO,SAASE;IACd7B,QAAQ8B,KAAK;AACf"}

package/src/lib/plugin-manager/interaction-step-checks.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * 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 InteractionStepBase, type SiteInteraction } from '../app-utils/site-interactions';
+/**
+ * THE CHECK OF A STEP THE PLATFORM DOES NOT KNOW (AGL-3080).
+ *
+ * `validateInteraction` checks what is the platform's own — the name, the
+ * trigger, the guards, the client steps and every declared pick — and leaves
+ * any other step to its owner, through `validateStep`. A plugin that edits
+ * interactions passes its own checks there. A plugin that only WRITES one —
+ * a recipe installed into a site, a drafted interaction graded before it is
+ * handed over — cannot import the plugin whose steps it wrote, and still has
+ * to refuse what that plugin would refuse.
+ *
+ * So the plugin that holds a step type's check registers it here, from its
+ * `declarations` entry (both apps and the console's browser run it at boot),
+ * and {@link validateStoredInteraction} runs the platform's checks with the
+ * registered ones. A step with no registered check is judged by the platform
+ * alone, as `validateInteraction` judges every step it was not told about.
+ *
+ * Reached by path, never through a barrel.
+ */
+/** One step's complaint, after its `Step N` prefix; `null` passes it. */
+export type InteractionStepCheck = (step: InteractionStepBase, label: string) => string | null;
+interface RegisteredCheck {
+    pluginId: string;
+    check: InteractionStepCheck;
+}
+/**
+ * Registers the check of one or more step types. Returns the unregister, which
+ * removes each type only while this check still holds it.
+ *
+ * The owner is the plugin whose register fn is running, or the `pluginId`
+ * passed for a boot declaration. A registration with neither is refused; so is
+ * a type another plugin's check already holds, because two checks of one step
+ * would each pass what the other refuses. The same plugin registering again
+ * replaces its own. Nothing is registered unless every type is accepted.
+ */
+export declare function registerInteractionStepChecks(types: readonly string[], check: InteractionStepCheck, options?: {
+    pluginId?: string;
+}): () => void;
+/** The check registered for a step type, with its owner, or `null`. */
+export declare function registeredInteractionStepCheck(type: string): RegisteredCheck | null;
+/**
+ * An interaction's problem as the platform and every registered step check see
+ * it, or `null`: what a plugin that writes an interaction it does not edit
+ * asks before it stores one.
+ */
+export declare function validateStoredInteraction(interaction: SiteInteraction<InteractionStepBase>): string | null;
+/** Only for specs: forgets every registered check. */
+export declare function resetInteractionStepChecksForTests(): void;
+export {};

package/src/lib/plugin-manager/interaction-step-checks.js

@@ -0,0 +1,86 @@
+var _globalScope_CHECKS_KEY;
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * 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 { getRegisteringPluginId } from "../app-utils/registering-plugin.js";
+import { validateInteraction } from "../app-utils/site-interactions.js";
+/**
+ * One table per process, on `globalThis` (AGL-3412): the server apps register
+ * from `instrumentation.ts`, which Next compiles apart from the routes that
+ * read, and a module-scoped map would be filled in one copy and read empty in
+ * the other.
+ */ const CHECKS_KEY = Symbol.for('@aglyn/aglyn:interaction-step-checks');
+const globalScope = globalThis;
+const checks = (_globalScope_CHECKS_KEY = globalScope[CHECKS_KEY]) != null ? _globalScope_CHECKS_KEY : globalScope[CHECKS_KEY] = new Map();
+const PLAIN_TYPE = /^[a-z][A-Za-z0-9]*$/;
+/**
+ * Registers the check of one or more step types. Returns the unregister, which
+ * removes each type only while this check still holds it.
+ *
+ * The owner is the plugin whose register fn is running, or the `pluginId`
+ * passed for a boot declaration. A registration with neither is refused; so is
+ * a type another plugin's check already holds, because two checks of one step
+ * would each pass what the other refuses. The same plugin registering again
+ * replaces its own. Nothing is registered unless every type is accepted.
+ */ export function registerInteractionStepChecks(types, check, options) {
+    var _ref, _getRegisteringPluginId;
+    const pluginId = ((_ref = (_getRegisteringPluginId = getRegisteringPluginId()) != null ? _getRegisteringPluginId : options == null ? void 0 : options.pluginId) != null ? _ref : '').trim();
+    if (!pluginId) {
+        throw new Error('an interaction step check was registered with no owner: pass { pluginId } ' + 'when registering outside a plugin register fn');
+    }
+    const list = [
+        ...new Set(types.map((type)=>type.trim()))
+    ];
+    if (!list.length) throw new Error(`"${pluginId}" registered an interaction step check for no step type`);
+    for (const type of list){
+        if (!PLAIN_TYPE.test(type)) {
+            throw new Error(`"${pluginId}" registered a check for "${type}", which is not a plain step type`);
+        }
+        const held = checks.get(type);
+        if (held && held.pluginId !== pluginId) {
+            throw new Error(`step "${type}" is already checked by "${held.pluginId}"; refused "${pluginId}"`);
+        }
+    }
+    const entry = {
+        pluginId,
+        check
+    };
+    for (const type of list)checks.set(type, entry);
+    return ()=>{
+        for (const type of list)if (checks.get(type) === entry) checks.delete(type);
+    };
+}
+/** The check registered for a step type, with its owner, or `null`. */ export function registeredInteractionStepCheck(type) {
+    var _checks_get;
+    return (_checks_get = checks.get(type)) != null ? _checks_get : null;
+}
+/**
+ * An interaction's problem as the platform and every registered step check see
+ * it, or `null`: what a plugin that writes an interaction it does not edit
+ * asks before it stores one.
+ */ export function validateStoredInteraction(interaction) {
+    return validateInteraction(interaction, {
+        validateStep: (step, label)=>{
+            var _ref;
+            var _checks_get;
+            return (_ref = (_checks_get = checks.get(step.type)) == null ? void 0 : _checks_get.check(step, label)) != null ? _ref : null;
+        }
+    });
+}
+/** Only for specs: forgets every registered check. */ export function resetInteractionStepChecksForTests() {
+    checks.clear();
+}
+
+//# sourceMappingURL=interaction-step-checks.js.map

package/src/lib/plugin-manager/interaction-step-checks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/plugin-manager/interaction-step-checks.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 { getRegisteringPluginId } from '../app-utils/registering-plugin'\nimport {\n  type InteractionStepBase,\n  type SiteInteraction,\n  validateInteraction,\n} from '../app-utils/site-interactions'\n\n/**\n * THE CHECK OF A STEP THE PLATFORM DOES NOT KNOW (AGL-3080).\n *\n * `validateInteraction` checks what is the platform's own — the name, the\n * trigger, the guards, the client steps and every declared pick — and leaves\n * any other step to its owner, through `validateStep`. A plugin that edits\n * interactions passes its own checks there. A plugin that only WRITES one —\n * a recipe installed into a site, a drafted interaction graded before it is\n * handed over — cannot import the plugin whose steps it wrote, and still has\n * to refuse what that plugin would refuse.\n *\n * So the plugin that holds a step type's check registers it here, from its\n * `declarations` entry (both apps and the console's browser run it at boot),\n * and {@link validateStoredInteraction} runs the platform's checks with the\n * registered ones. A step with no registered check is judged by the platform\n * alone, as `validateInteraction` judges every step it was not told about.\n *\n * Reached by path, never through a barrel.\n */\n\n/** One step's complaint, after its `Step N` prefix; `null` passes it. */\nexport type InteractionStepCheck = (step: InteractionStepBase, label: string) => string | null\n\ninterface RegisteredCheck {\n  pluginId: string\n  check: InteractionStepCheck\n}\n\n/**\n * One table per process, on `globalThis` (AGL-3412): the server apps register\n * from `instrumentation.ts`, which Next compiles apart from the routes that\n * read, and a module-scoped map would be filled in one copy and read empty in\n * the other.\n */\nconst CHECKS_KEY = Symbol.for('@aglyn/aglyn:interaction-step-checks')\n\nconst globalScope = globalThis as typeof globalThis & {\n  [CHECKS_KEY]?: Map<string, RegisteredCheck>\n}\n\nconst checks: Map<string, RegisteredCheck> =\n  globalScope[CHECKS_KEY] ?? (globalScope[CHECKS_KEY] = new Map())\n\nconst PLAIN_TYPE = /^[a-z][A-Za-z0-9]*$/\n\n/**\n * Registers the check of one or more step types. Returns the unregister, which\n * removes each type only while this check still holds it.\n *\n * The owner is the plugin whose register fn is running, or the `pluginId`\n * passed for a boot declaration. A registration with neither is refused; so is\n * a type another plugin's check already holds, because two checks of one step\n * would each pass what the other refuses. The same plugin registering again\n * replaces its own. Nothing is registered unless every type is accepted.\n */\nexport function registerInteractionStepChecks(\n  types: readonly string[],\n  check: InteractionStepCheck,\n  options?: { pluginId?: string },\n): () => void {\n  const pluginId = (getRegisteringPluginId() ?? options?.pluginId ?? '').trim()\n  if (!pluginId) {\n    throw new Error(\n      'an interaction step check was registered with no owner: pass { pluginId } ' +\n        'when registering outside a plugin register fn',\n    )\n  }\n  const list = [...new Set(types.map((type) => type.trim()))]\n  if (!list.length) throw new Error(`\"${pluginId}\" registered an interaction step check for no step type`)\n  for (const type of list) {\n    if (!PLAIN_TYPE.test(type)) {\n      throw new Error(`\"${pluginId}\" registered a check for \"${type}\", which is not a plain step type`)\n    }\n    const held = checks.get(type)\n    if (held && held.pluginId !== pluginId) {\n      throw new Error(`step \"${type}\" is already checked by \"${held.pluginId}\"; refused \"${pluginId}\"`)\n    }\n  }\n  const entry: RegisteredCheck = { pluginId, check }\n  for (const type of list) checks.set(type, entry)\n  return () => {\n    for (const type of list) if (checks.get(type) === entry) checks.delete(type)\n  }\n}\n\n/** The check registered for a step type, with its owner, or `null`. */\nexport function registeredInteractionStepCheck(type: string): RegisteredCheck | null {\n  return checks.get(type) ?? null\n}\n\n/**\n * An interaction's problem as the platform and every registered step check see\n * it, or `null`: what a plugin that writes an interaction it does not edit\n * asks before it stores one.\n */\nexport function validateStoredInteraction(\n  interaction: SiteInteraction<InteractionStepBase>,\n): string | null {\n  return validateInteraction(interaction, {\n    validateStep: (step, label) => checks.get(step.type)?.check(step, label) ?? null,\n  })\n}\n\n/** Only for specs: forgets every registered check. */\nexport function resetInteractionStepChecksForTests(): void {\n  checks.clear()\n}\n"],"names":["globalScope","getRegisteringPluginId","validateInteraction","CHECKS_KEY","Symbol","for","globalThis","checks","Map","PLAIN_TYPE","registerInteractionStepChecks","types","check","options","pluginId","trim","Error","list","Set","map","type","length","test","held","get","entry","set","delete","registeredInteractionStepCheck","validateStoredInteraction","interaction","validateStep","step","label","resetInteractionStepChecksForTests","clear"],"mappings":"IAiEEA;AAjEF;;;;;;;;;;;;;;;CAeC,GAED,SAASC,sBAAsB,QAAQ,qCAAiC;AACxE,SAGEC,mBAAmB,QACd,oCAAgC;AA8BvC;;;;;CAKC,GACD,MAAMC,aAAaC,OAAOC,GAAG,CAAC;AAE9B,MAAML,cAAcM;AAIpB,MAAMC,UACJP,0BAAAA,WAAW,CAACG,WAAW,YAAvBH,0BAA4BA,WAAW,CAACG,WAAW,GAAG,IAAIK;AAE5D,MAAMC,aAAa;AAEnB;;;;;;;;;CASC,GACD,OAAO,SAASC,8BACdC,KAAwB,EACxBC,KAA2B,EAC3BC,OAA+B;QAEbZ,MAAAA;IAAlB,MAAMa,WAAW,EAACb,QAAAA,0BAAAA,oCAAAA,0BAA4BY,2BAAAA,QAASC,QAAQ,YAA7Cb,OAAiD,IAAIc,IAAI;IAC3E,IAAI,CAACD,UAAU;QACb,MAAM,IAAIE,MACR,+EACE;IAEN;IACA,MAAMC,OAAO;WAAI,IAAIC,IAAIP,MAAMQ,GAAG,CAAC,CAACC,OAASA,KAAKL,IAAI;KAAK;IAC3D,IAAI,CAACE,KAAKI,MAAM,EAAE,MAAM,IAAIL,MAAM,CAAC,CAAC,EAAEF,SAAS,uDAAuD,CAAC;IACvG,KAAK,MAAMM,QAAQH,KAAM;QACvB,IAAI,CAACR,WAAWa,IAAI,CAACF,OAAO;YAC1B,MAAM,IAAIJ,MAAM,CAAC,CAAC,EAAEF,SAAS,0BAA0B,EAAEM,KAAK,iCAAiC,CAAC;QAClG;QACA,MAAMG,OAAOhB,OAAOiB,GAAG,CAACJ;QACxB,IAAIG,QAAQA,KAAKT,QAAQ,KAAKA,UAAU;YACtC,MAAM,IAAIE,MAAM,CAAC,MAAM,EAAEI,KAAK,yBAAyB,EAAEG,KAAKT,QAAQ,CAAC,YAAY,EAAEA,SAAS,CAAC,CAAC;QAClG;IACF;IACA,MAAMW,QAAyB;QAAEX;QAAUF;IAAM;IACjD,KAAK,MAAMQ,QAAQH,KAAMV,OAAOmB,GAAG,CAACN,MAAMK;IAC1C,OAAO;QACL,KAAK,MAAML,QAAQH,KAAM,IAAIV,OAAOiB,GAAG,CAACJ,UAAUK,OAAOlB,OAAOoB,MAAM,CAACP;IACzE;AACF;AAEA,qEAAqE,GACrE,OAAO,SAASQ,+BAA+BR,IAAY;QAClDb;IAAP,QAAOA,cAAAA,OAAOiB,GAAG,CAACJ,iBAAXb,cAAoB;AAC7B;AAEA;;;;CAIC,GACD,OAAO,SAASsB,0BACdC,WAAiD;IAEjD,OAAO5B,oBAAoB4B,aAAa;QACtCC,cAAc,CAACC,MAAMC;;gBAAU1B;4BAAAA,cAAAA,OAAOiB,GAAG,CAACQ,KAAKZ,IAAI,sBAApBb,YAAuBK,KAAK,CAACoB,MAAMC,yBAAU;;IAC9E;AACF;AAEA,oDAAoD,GACpD,OAAO,SAASC;IACd3B,OAAO4B,KAAK;AACd"}

package/src/lib/plugin-manager/plugin-artifact-types.d.ts

@@ -0,0 +1,235 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * 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 { InstalledFrom } from '../app-utils/artifact-provenance';
+/**
+ * AN INSTALLABLE ARTIFACT TYPE ANOTHER PLUGIN KEEPS (AGL-3080).
+ *
+ * Installed content is the platform's concept (`artifact-provenance.ts`): a
+ * workspace can take a component, a theme or a dataset's schema from a
+ * publisher rather than author it. The plugin that sells, installs and
+ * updates those copies is one plugin; the plugin whose storage a copy lands
+ * in may be another. A dataset schema is published from a dataset and
+ * installs as a new one, and datasets are the data plugin's. The installer
+ * may not read or write another plugin's storage, and neither plugin may
+ * import the other, so this is the contract between them, and core names
+ * neither.
+ *
+ * The owner answers four questions, and the installer keeps everything else:
+ * who may act, the listing, its takedown and privacy gates, the purchase, the
+ * publisher's preconditions, the provenance stamp and its base snapshot, and
+ * the per-version tally.
+ *
+ * 1. {@link PluginArtifactOwner.snapshot}: publishing. Reads the source the
+ *    publisher named in their own workspace and reduces it to what may travel.
+ *    The installer stores what comes back as the version's content.
+ * 2. {@link PluginArtifactOwner.admits}: before an install reads its listing,
+ *    whether this workspace may hold one at all (its plan).
+ * 3. {@link PluginArtifactOwner.prepare}: installing. Checks the published
+ *    content can land here, makes it this workspace's, and writes NOTHING. The
+ *    installer records provenance over the prepared content, then calls
+ *    `commit` to write the copy with that stamp.
+ * 4. {@link PluginArtifactOwner.locate}: updating. Finds the copy a listing
+ *    installed, and hands back what the three-way merge diffs together with
+ *    the one write that applies its result.
+ *
+ * ## Declared, then registered, and an absent owner refuses
+ *
+ * The owner DECLARES each type in `plugins.config.json` (`artifactTypes`),
+ * compiled into core, and registers its answers from a declarations entry
+ * (`consoleServerDeclarations`: an install runs on the console's server). A
+ * registry alone would read a failed boot as "nobody keeps this type". The
+ * three cases stay apart:
+ *
+ * - nothing declares the type: {@link resolveArtifactTypeOwner} answers
+ *   `null`, and the installer refuses the listing as unavailable here;
+ * - declared and registered: the owner answers;
+ * - declared and NOT registered: the app's declarations step runs again, and
+ *   if the owner is still missing this THROWS
+ *   {@link ArtifactTypeOwnerUnavailableError}.
+ *
+ * Every one of those is decided before the installer writes anything, so an
+ * install with no owner refuses whole and never lands half: no copy, no
+ * provenance, no tally.
+ *
+ * Server-only, and reached by its own subpath, never through a barrel.
+ */
+/** A compiled declaration: the artifact type, and the plugin that keeps its copies. */
+export interface ArtifactTypeDeclaration {
+    pluginId: string;
+    type: string;
+}
+/** A refusal, answered as the route's status and `{ error }` body. */
+export interface ArtifactRefusal {
+    ok: false;
+    status: number;
+    error: string;
+}
+/** The workspace a copy is installed into. */
+export interface ArtifactWorkspace {
+    /** The organization the copy lands in. */
+    orgId: string;
+    /** Its organization document: the plan, add-ons and default sharing a copy is held to. */
+    org: Readonly<Record<string, unknown>>;
+}
+/** The listing a copy is installed from, as the listing stores it. */
+export interface ArtifactListingFacts {
+    listingId: string;
+    displayName?: unknown;
+    description?: unknown;
+    /** The version on offer: the listing's `latestVersion`. */
+    version?: unknown;
+}
+/**
+ * Where a copy came from, written onto it by its owner. The installer makes
+ * both: the owner stores them and never composes either.
+ */
+export interface ArtifactInstallStamp {
+    /** The provenance every installed copy carries (AGL-1015). */
+    installedFrom: InstalledFrom;
+    /** The installer's own word for the copy's origin, with the listing and version. */
+    source: {
+        type: string;
+        listingId: string;
+        version: unknown;
+    };
+}
+/** Publishing: the source a publisher named, in their own workspace. */
+export interface ArtifactSnapshotRequest {
+    /** The publishing organization, whose source is read. */
+    orgId: string;
+    /** The id of the source the publisher named. */
+    sourceId: string;
+}
+/** What a published version of the type carries. */
+export interface ArtifactSnapshot {
+    ok: true;
+    /** The content every install of this version receives. */
+    content: unknown;
+    /** Facts about the content the listing carries beside it, written as they are. */
+    facts?: Readonly<Record<string, string | number | boolean>>;
+}
+/** Installing: one published version, into one workspace. */
+export interface ArtifactInstallRequest extends ArtifactWorkspace {
+    listing: ArtifactListingFacts;
+    /** The version's content as published (`versions/{v}.{type}`), unvalidated. */
+    published: unknown;
+}
+/** What an install landed, reported beside the installer's own fields. */
+export interface ArtifactInstalled {
+    ok: true;
+    report: Readonly<Record<string, unknown>>;
+}
+/** An install the owner has checked and not yet written. */
+export interface PreparedArtifactInstall {
+    ok: true;
+    /**
+     * The content exactly as the copy will hold it: what the installer records
+     * as the base snapshot, so an update diffs this workspace's copy against
+     * what really arrived rather than what the publisher sent.
+     */
+    content: unknown;
+    /**
+     * Writes the copy with the installer's stamp. It may still refuse (a cap
+     * that a concurrent install reached first), and a refusal writes nothing.
+     */
+    commit(stamp: ArtifactInstallStamp): Promise<ArtifactInstalled | ArtifactRefusal>;
+}
+/** Updating: the copy a listing installed, asked from one site. */
+export interface ArtifactLocateRequest {
+    /** The site's organization, or `null` for a site with none. */
+    orgId: string | null;
+    /** The site the update was asked from. */
+    hostId: string;
+    listingId: string;
+    /** The version on offer, as published, unvalidated. */
+    published: unknown;
+}
+/**
+ * What taking an update does beyond its content: shown on the preview, and,
+ * when `destructive`, applied only once the caller has confirmed it.
+ */
+export interface ArtifactUpdateImpact {
+    /** Fields added to the update's preview as they are. */
+    preview: Readonly<Record<string, unknown>>;
+    /** The update reinterprets something the copy already holds. */
+    destructive: boolean;
+    /** The sentence an unconfirmed destructive merge is refused with. */
+    refusal: string;
+}
+/** The installed copy, in the shape its base snapshot holds. */
+export interface InstalledArtifactCopy {
+    ok: true;
+    /** The copy as it is now. */
+    current: unknown;
+    /** The version on offer, made this workspace's exactly as an install would. */
+    incoming: unknown;
+    /** The version the copy was installed at, or `null` when it does not say. */
+    installedVersion: string | null;
+    /** The hash of the base snapshot it was installed with, or `null`. */
+    baseSha: string | null;
+    impact?: ArtifactUpdateImpact;
+    /** Writes the merged content onto the copy, with the update's stamp. */
+    apply(update: {
+        content: unknown;
+        stamp: ArtifactInstallStamp;
+    }): Promise<void>;
+}
+/** A plugin's answers for an installable artifact type it keeps. */
+export interface PluginArtifactOwner {
+    snapshot(request: ArtifactSnapshotRequest): Promise<ArtifactSnapshot | ArtifactRefusal>;
+    admits(workspace: ArtifactWorkspace): Promise<ArtifactRefusal | null>;
+    prepare(request: ArtifactInstallRequest): Promise<PreparedArtifactInstall | ArtifactRefusal>;
+    locate(request: ArtifactLocateRequest): Promise<InstalledArtifactCopy | ArtifactRefusal>;
+}
+/** Every declared type, in config order. */
+export declare function listDeclaredArtifactTypes(): readonly ArtifactTypeDeclaration[];
+/** The plugin declared as keeping `type`, or `null` when none is. */
+export declare function declaredArtifactTypeOwner(type: string): ArtifactTypeDeclaration | null;
+interface Registered {
+    pluginId: string;
+    owner: PluginArtifactOwner;
+}
+/**
+ * Registers a plugin's answers for a type it declared. The owner is the plugin
+ * whose register fn is running, or the `pluginId` passed from a boot
+ * declaration. Refused: no owner, a type nobody declared (no installer would
+ * ever ask for it), and a type another plugin declared. The same plugin
+ * registering again replaces its answers. Returns the unregister.
+ */
+export declare function registerArtifactTypeOwner(type: string, owner: PluginArtifactOwner, options?: {
+    pluginId?: string;
+}): () => void;
+/** The registered owner of `type` with its plugin, or `null`. */
+export declare function artifactTypeOwner(type: string): Registered | null;
+/** Only for specs: forgets every registered owner. */
+export declare function resetArtifactTypeOwnersForTests(): void;
+/**
+ * The declared owner's registration was not found, even after the app's
+ * declarations step ran again.
+ */
+export declare class ArtifactTypeOwnerUnavailableError extends Error {
+    readonly declared: ArtifactTypeDeclaration;
+    constructor(declared: ArtifactTypeDeclaration);
+}
+/**
+ * The owner of `type`: `null` when no plugin declares it, the registered
+ * answers when one does, and a THROWN {@link ArtifactTypeOwnerUnavailableError}
+ * when the declared owner is still missing after the app's declarations step
+ * ran once more.
+ */
+export declare function resolveArtifactTypeOwner(type: string): Promise<PluginArtifactOwner | null>;
+export {};

package/src/lib/plugin-manager/plugin-artifact-types.js

@@ -0,0 +1,99 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * 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.
+ */ var _globalScope_OWNERS_KEY;
+import { getRegisteringPluginId } from "../app-utils/registering-plugin.js";
+import { PLUGIN_ARTIFACT_TYPES_DECLARED } from "./first-party-plugins.generated.js";
+import { runPluginDeclarationsRepair } from "./plugin-declarations-repair.js";
+/** Every declared type, in config order. */ export function listDeclaredArtifactTypes() {
+    return PLUGIN_ARTIFACT_TYPES_DECLARED;
+}
+/** The plugin declared as keeping `type`, or `null` when none is. */ export function declaredArtifactTypeOwner(type) {
+    var _listDeclaredArtifactTypes_find;
+    return (_listDeclaredArtifactTypes_find = listDeclaredArtifactTypes().find((declared)=>declared.type === type)) != null ? _listDeclaredArtifactTypes_find : null;
+}
+/**
+ * One table per process, on `globalThis` (AGL-3412): the owner registers from
+ * the app's boot, which Next compiles apart from the routes that read.
+ */ const OWNERS_KEY = Symbol.for('@aglyn/aglyn:plugin-artifact-types');
+const globalScope = globalThis;
+const owners = (_globalScope_OWNERS_KEY = globalScope[OWNERS_KEY]) != null ? _globalScope_OWNERS_KEY : globalScope[OWNERS_KEY] = new Map();
+/**
+ * Registers a plugin's answers for a type it declared. The owner is the plugin
+ * whose register fn is running, or the `pluginId` passed from a boot
+ * declaration. Refused: no owner, a type nobody declared (no installer would
+ * ever ask for it), and a type another plugin declared. The same plugin
+ * registering again replaces its answers. Returns the unregister.
+ */ export function registerArtifactTypeOwner(type, owner, options) {
+    var _ref, _getRegisteringPluginId;
+    const name = type.trim();
+    const pluginId = ((_ref = (_getRegisteringPluginId = getRegisteringPluginId()) != null ? _getRegisteringPluginId : options == null ? void 0 : options.pluginId) != null ? _ref : '').trim();
+    if (!pluginId) {
+        throw new Error(`artifact type "${name}" registered with no owner: pass { pluginId } ` + 'when registering outside a plugin register fn');
+    }
+    const declared = declaredArtifactTypeOwner(name);
+    if (!declared) {
+        throw new Error(`artifact type "${name}" is not declared in plugins.config.json ` + '(artifactTypes), so no installer would ever ask for it');
+    }
+    if (declared.pluginId !== pluginId) {
+        throw new Error(`artifact type "${name}" is declared by "${declared.pluginId}"; refused "${pluginId}"`);
+    }
+    const entry = {
+        pluginId,
+        owner
+    };
+    owners.set(name, entry);
+    return ()=>{
+        if (owners.get(name) === entry) owners.delete(name);
+    };
+}
+/** The registered owner of `type` with its plugin, or `null`. */ export function artifactTypeOwner(type) {
+    var _owners_get;
+    return (_owners_get = owners.get(type)) != null ? _owners_get : null;
+}
+/** Only for specs: forgets every registered owner. */ export function resetArtifactTypeOwnersForTests() {
+    owners.clear();
+}
+/**
+ * The declared owner's registration was not found, even after the app's
+ * declarations step ran again.
+ */ export class ArtifactTypeOwnerUnavailableError extends Error {
+    constructor(declared){
+        super(`artifact type "${declared.type}" is declared by "${declared.pluginId}" but ` + 'no owner is registered in this process: its declarations did not run. ' + 'Refusing to treat it as a type nobody keeps.'), this.declared = declared;
+        this.name = 'ArtifactTypeOwnerUnavailableError';
+    }
+}
+/**
+ * The owner of `type`: `null` when no plugin declares it, the registered
+ * answers when one does, and a THROWN {@link ArtifactTypeOwnerUnavailableError}
+ * when the declared owner is still missing after the app's declarations step
+ * ran once more.
+ */ export async function resolveArtifactTypeOwner(type) {
+    const declared = declaredArtifactTypeOwner(type);
+    if (!declared) return null;
+    let registered = artifactTypeOwner(type);
+    if (!registered) {
+        try {
+            await runPluginDeclarationsRepair();
+        } catch (error) {
+            console.error('[plugin-artifact-types] the declarations repair failed', error);
+        }
+        registered = artifactTypeOwner(type);
+    }
+    if (!registered) throw new ArtifactTypeOwnerUnavailableError(declared);
+    return registered.owner;
+}
+
+//# sourceMappingURL=plugin-artifact-types.js.map