@things-factory/worklist 10.1.248 → 10.1.249

package/dist-server/service/activity/decision-key-declaration.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Refuses a decisionKeys declaration that cannot draw, and computes the i18n keys an activity's
+ * sentences are read from.
+ *
+ * ── This path is read from outside ────────────────────────────────────────
+ * operato-plant's tests import this file by its built path,
+ * `@things-factory/worklist/dist-server/service/activity/decision-key-declaration.js`, for
+ * DECISION_ROLES, doorSlug and activityTKey. Moving or renaming it breaks those tests, so treat the
+ * path as public.
+ *
+ * Refusing a declaration that cannot draw:
+ *
+ * Same reasoning as search keys: a declaration that does not work should fail where it arrives, not
+ * where someone opens an approval. The difference is what "not working" means here — nothing is
+ * dropped by a save, so the failure would be a screen that quietly draws less than it was told to.
+ *
+ * The shape is spelled out rather than imported. ActivityDecisionKeyItem carries type-graphql
+ * decorators and the test runner strips types without reading them, so importing the declared class
+ * pulls type-graphql in and the test file fails to load.
+ */
+type DecisionKeyDeclaration = {
+    role?: string;
+    inputPath?: string;
+    valueTKey?: string;
+    params?: {
+        [name: string]: string;
+    };
+};
+/** Roles a screen knows how to draw. Widening this is an architecture decision, not a lane's. */
+export declare const DECISION_ROLES: readonly ["headline", "subject", "reversibility", "reason", "evidence", "currentState", "consequence"];
+/**
+ * The roles that may appear more than once.
+ *
+ * An approval can change several things at once — plant's priority change pushes some orders back
+ * and moves others ahead — and those are separate consequences, not one merged sentence. Grounds
+ * come in several the same way: which inspection, against which spec, decided when.
+ *
+ * Every other role names a single value. Two headlines would leave the screen picking one with
+ * nothing to say why.
+ *
+ * Named consequence, not effect: TwinCommand.effect is what the source reported back after dispatch
+ * — an observation, and past — while this is a prediction, and future.
+ */
+export declare const REPEATABLE_ROLES: readonly ["consequence", "evidence"];
+/**
+ * The door's part of a value key — the activity's name, kebab-cased.
+ *
+ * ── Why computed and not declared ─────────────────────────────────────────
+ * A declared key is a key table, and a key table is what a computed key exists to avoid: nobody
+ * writing a new door picks a key, so none of them can be picked wrong, and a test can count every
+ * key that exists rather than every key somebody remembered to register.
+ *
+ * It is safe to hang this on `name` because `name` cannot move — it is the key the callback is
+ * found by, and renaming it makes an approval finish with nothing happening. A key derived from a
+ * fixed name is fixed.
+ *
+ * ── The boundary rule ─────────────────────────────────────────────────────
+ * Activity names come in two shapes and this repository has both: 'MES Disposition Approval' and
+ * 'BatchRelease'. Splitting only on spaces would leave `batchrelease` beside `mes-disposition-
+ * approval`; splitting on every capital would turn 'MES' into `m-e-s`. So the split is between a
+ * lowercase or digit and a capital, and between a run of capitals and a capitalised word — the same
+ * rule `secretEnvName` uses, written after HOOKSECRET and HOOK_SECRET drifted apart.
+ */
+export declare function doorSlug(activityName: string): string;
+/**
+ * The i18n key for one slot's **value sentence** — `approval.<door>.<inputPath>`.
+ *
+ * `inputPath` and not `role`: a door repeats `consequence`, so two slots in one door would collide
+ * on role and the later sentence would silently take the earlier one's key. `inputPath` is the one
+ * thing already unique within a door, and it is already written in the declaration.
+ */
+export declare function decisionValueKey(activityName: string, inputPath: string): string;
+/**
+ * The i18n key for an activity's own sentences — `activity.<door>.label`, `activity.<door>.guide.<n>`.
+ *
+ * Computed from `name` for the reason decisionValueKey is: nobody picks the key, so none is picked
+ * wrong, and an app's test can walk its declarations and count every key that must exist.
+ *
+ * The server sends the result (Activity.labelTKey, InstallableActivity.labelTKey and guideTKeys);
+ * screens draw `t(labelTKey, { defaultValue: label })` and never rebuild the slug. A client file that
+ * imported this one would move the whole client build under dist-client/client/.
+ *
+ * `description` has no key. It is the developers' English line and is not shown to the person
+ * doing the work.
+ *
+ * Guide lines are keyed by position. Inserting a line shifts every later translation by one, and a
+ * count of keys does not notice — change guide and its translations in the same edit.
+ */
+export declare function activityTKey(activityName: string, part: 'label' | 'readiness-notes'): string;
+export declare function activityTKey(activityName: string, part: 'guide' | 'readiness-gap', index: number): string;
+/**
+ * One key per guide line, **always as many as there are lines.** The screen pairs the two arrays
+ * by position; a shorter key list would send the last lines out untranslated with nothing to show it.
+ */
+export declare function activityGuideTKeys(activityName: string, guide: string[] | undefined | null): string[];
+/**
+ * The same for what a module declares about its own readiness.
+ *
+ * The catalog screen draws `readiness.gaps` and `readiness.notes` as sentences, and those come out
+ * of a catalog that is built at boot, before anyone's locale is known. So the module keeps writing
+ * sentences and the screen reads a translation of them, exactly as it does for label and guide
+ * (ADR-0054: the sentence is chosen where `context.t` is).
+ */
+export declare function activityReadinessGapTKeys(activityName: string, gaps: string[] | undefined | null): string[];
+export declare function assertDecisionKeysAreUsable(decisionKeys: DecisionKeyDeclaration[] | undefined, activityName?: string): void;
+export {};

package/dist-server/service/activity/decision-key-declaration.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REPEATABLE_ROLES = exports.DECISION_ROLES = void 0;
+exports.doorSlug = doorSlug;
+exports.decisionValueKey = decisionValueKey;
+exports.activityTKey = activityTKey;
+exports.activityGuideTKeys = activityGuideTKeys;
+exports.activityReadinessGapTKeys = activityReadinessGapTKeys;
+exports.assertDecisionKeysAreUsable = assertDecisionKeysAreUsable;
+/** Roles a screen knows how to draw. Widening this is an architecture decision, not a lane's. */
+exports.DECISION_ROLES = [
+    'headline',
+    'subject',
+    'reversibility',
+    'reason',
+    'evidence',
+    'currentState',
+    'consequence'
+];
+/**
+ * The roles that may appear more than once.
+ *
+ * An approval can change several things at once — plant's priority change pushes some orders back
+ * and moves others ahead — and those are separate consequences, not one merged sentence. Grounds
+ * come in several the same way: which inspection, against which spec, decided when.
+ *
+ * Every other role names a single value. Two headlines would leave the screen picking one with
+ * nothing to say why.
+ *
+ * Named consequence, not effect: TwinCommand.effect is what the source reported back after dispatch
+ * — an observation, and past — while this is a prediction, and future.
+ */
+exports.REPEATABLE_ROLES = ['consequence', 'evidence'];
+/**
+ * The door's part of a value key — the activity's name, kebab-cased.
+ *
+ * ── Why computed and not declared ─────────────────────────────────────────
+ * A declared key is a key table, and a key table is what a computed key exists to avoid: nobody
+ * writing a new door picks a key, so none of them can be picked wrong, and a test can count every
+ * key that exists rather than every key somebody remembered to register.
+ *
+ * It is safe to hang this on `name` because `name` cannot move — it is the key the callback is
+ * found by, and renaming it makes an approval finish with nothing happening. A key derived from a
+ * fixed name is fixed.
+ *
+ * ── The boundary rule ─────────────────────────────────────────────────────
+ * Activity names come in two shapes and this repository has both: 'MES Disposition Approval' and
+ * 'BatchRelease'. Splitting only on spaces would leave `batchrelease` beside `mes-disposition-
+ * approval`; splitting on every capital would turn 'MES' into `m-e-s`. So the split is between a
+ * lowercase or digit and a capital, and between a run of capitals and a capitalised word — the same
+ * rule `secretEnvName` uses, written after HOOKSECRET and HOOK_SECRET drifted apart.
+ */
+function doorSlug(activityName) {
+    return String(activityName ?? '')
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+        .replace(/[^A-Za-z0-9]+/g, '-')
+        .toLowerCase()
+        .replace(/^-+|-+$/g, '');
+}
+/**
+ * The i18n key for one slot's **value sentence** — `approval.<door>.<inputPath>`.
+ *
+ * `inputPath` and not `role`: a door repeats `consequence`, so two slots in one door would collide
+ * on role and the later sentence would silently take the earlier one's key. `inputPath` is the one
+ * thing already unique within a door, and it is already written in the declaration.
+ */
+function decisionValueKey(activityName, inputPath) {
+    return `approval.${doorSlug(activityName)}.${inputPath}`;
+}
+function activityTKey(activityName, part, index) {
+    const door = `activity.${doorSlug(activityName)}`;
+    switch (part) {
+        case 'guide':
+            return `${door}.guide.${index}`;
+        case 'readiness-gap':
+            return `${door}.readiness-gap.${index}`;
+        case 'readiness-notes':
+            return `${door}.readiness-notes`;
+        default:
+            return `${door}.label`;
+    }
+}
+/**
+ * One key per guide line, **always as many as there are lines.** The screen pairs the two arrays
+ * by position; a shorter key list would send the last lines out untranslated with nothing to show it.
+ */
+function activityGuideTKeys(activityName, guide) {
+    return (guide || []).map((_, index) => activityTKey(activityName, 'guide', index));
+}
+/**
+ * The same for what a module declares about its own readiness.
+ *
+ * The catalog screen draws `readiness.gaps` and `readiness.notes` as sentences, and those come out
+ * of a catalog that is built at boot, before anyone's locale is known. So the module keeps writing
+ * sentences and the screen reads a translation of them, exactly as it does for label and guide
+ * (ADR-0054: the sentence is chosen where `context.t` is).
+ */
+function activityReadinessGapTKeys(activityName, gaps) {
+    return (gaps || []).map((_, index) => activityTKey(activityName, 'readiness-gap', index));
+}
+function assertDecisionKeysAreUsable(decisionKeys, activityName) {
+    if (!decisionKeys?.length) {
+        return;
+    }
+    const named = activityName ? `activity "${activityName}"` : 'this activity';
+    const unknown = decisionKeys.filter(key => !exports.DECISION_ROLES.includes(String(key?.role ?? '')));
+    if (unknown.length) {
+        throw new Error(`${named} declares decision keys with a role the approval screen does not know: ` +
+            `${unknown.map(key => `"${key?.role ?? ''}"`).join(', ')}. ` +
+            `Known roles are ${exports.DECISION_ROLES.join(', ')}. A role outside that set draws nothing.`);
+    }
+    const pathless = decisionKeys.filter(key => !String(key?.inputPath ?? '').trim());
+    if (pathless.length) {
+        throw new Error(`${named} declares ${pathless.length} decision key(s) with no inputPath. ` +
+            `A decision key names the value it draws; without a path there is nothing to read.`);
+    }
+    /*
+     * An index or a wildcard resolves to nothing at draw time and the slot would report "the path led
+     * nowhere" — which reads as a payload that disagrees with the declaration, when the truth is that
+     * the declaration used a path language that does not exist. Refusing here says which it was.
+     */
+    const notPaths = decisionKeys.filter(key => /[[\]*]/.test(String(key?.inputPath ?? '')));
+    if (notPaths.length) {
+        throw new Error(`${named} declares decision keys whose inputPath is not a plain dotted path: ` +
+            `${notPaths.map(key => `"${key?.inputPath ?? ''}"`).join(', ')}. ` +
+            `Dots only — no array index and no wildcard. Point at the list itself; drawing its items is ` +
+            `the slot's work.`);
+    }
+    const repeated = exports.DECISION_ROLES.filter(role => !exports.REPEATABLE_ROLES.includes(role) &&
+        decisionKeys.filter(key => key?.role === role).length > 1);
+    if (repeated.length) {
+        throw new Error(`${named} declares more than one "${repeated.join('", "')}" decision key. ` +
+            `Only ${exports.REPEATABLE_ROLES.map(role => `"${role}"`).join(' and ')} may repeat — an approval can ` +
+            `change several things at once, and grounds come in several. The screen would draw one of the ` +
+            `others and could not say which.`);
+    }
+    /*
+     * A sentence may only be built from values that were snapshotted, so every params value is an
+     * inputPath and reads by the same rules. Wanting a value with no field behind it means the field
+     * is missing, not that params needs a second source — the two hold each other up: without the
+     * value the sentence cannot be rebuilt, and a value a sentence uses is guaranteed to stay.
+     *
+     * Only the right side has a rule. The names on the left belong to the sentence and are the
+     * locale file's business.
+     */
+    const badParams = [];
+    for (const key of decisionKeys) {
+        for (const [name, path] of Object.entries(key?.params || {})) {
+            const said = String(path ?? '');
+            if (!said.trim()) {
+                badParams.push(`"${name}" (empty)`);
+            }
+            else if (/[[\]*]/.test(said)) {
+                badParams.push(`"${name}": "${said}"`);
+            }
+        }
+    }
+    if (badParams.length) {
+        throw new Error(`${named} declares sentence params that are not plain dotted paths into the input: ` +
+            `${badParams.join(', ')}. Every params value is an inputPath — a sentence is built only from ` +
+            `values the request froze, so a value with nowhere to read it from is a missing field.`);
+    }
+    if (!activityName) {
+        return;
+    }
+    /*
+     * The key is computed, so a declared one that disagrees is a typo that would draw `approval.…` on
+     * the card. Checking it here rather than trusting the writer is the whole reason it is computed.
+     */
+    const wrongKey = decisionKeys.filter(key => key?.valueTKey && key.valueTKey !== decisionValueKey(activityName, String(key?.inputPath ?? '')));
+    if (wrongKey.length) {
+        throw new Error(`${named} declares value keys that are not the computed ones: ` +
+            `${wrongKey
+                .map(key => `"${key?.valueTKey}" (expected "${decisionValueKey(activityName, String(key?.inputPath ?? ''))}")`)
+                .join(', ')}. ` +
+            `The key is approval.<door>.<inputPath> and nobody picks it — a key nobody can pick is a key ` +
+            `nobody can pick wrong.`);
+    }
+}
+//# sourceMappingURL=decision-key-declaration.js.map

package/dist-server/service/activity/decision-key-declaration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision-key-declaration.js","sourceRoot":"","sources":["../../../server/service/activity/decision-key-declaration.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Refuses a decisionKeys declaration that cannot draw, and computes the i18n keys an activity's\n * sentences are read from.\n *\n * ── This path is read from outside ────────────────────────────────────────\n * operato-plant's tests import this file by its built path,\n * `@things-factory/worklist/dist-server/service/activity/decision-key-declaration.js`, for\n * DECISION_ROLES, doorSlug and activityTKey. Moving or renaming it breaks those tests, so treat the\n * path as public.\n *\n * Refusing a declaration that cannot draw:\n *\n * Same reasoning as search keys: a declaration that does not work should fail where it arrives, not\n * where someone opens an approval. The difference is what \"not working\" means here — nothing is\n * dropped by a save, so the failure would be a screen that quietly draws less than it was told to.\n *\n * The shape is spelled out rather than imported. ActivityDecisionKeyItem carries type-graphql\n * decorators and the test runner strips types without reading them, so importing the declared class\n * pulls type-graphql in and the test file fails to load.\n */\ntype DecisionKeyDeclaration = {\n  role?: string\n  inputPath?: string\n  valueTKey?: string\n  params?: { [name: string]: string }\n}\n\n/** Roles a screen knows how to draw. Widening this is an architecture decision, not a lane's. */\nexport const DECISION_ROLES = [\n  'headline',\n  'subject',\n  'reversibility',\n  'reason',\n  'evidence',\n  'currentState',\n  'consequence'\n] as const\n\n/**\n * The roles that may appear more than once.\n *\n * An approval can change several things at once — plant's priority change pushes some orders back\n * and moves others ahead — and those are separate consequences, not one merged sentence. Grounds\n * come in several the same way: which inspection, against which spec, decided when.\n *\n * Every other role names a single value. Two headlines would leave the screen picking one with\n * nothing to say why.\n *\n * Named consequence, not effect: TwinCommand.effect is what the source reported back after dispatch\n * — an observation, and past — while this is a prediction, and future.\n */\nexport const REPEATABLE_ROLES = ['consequence', 'evidence'] as const\n\n/**\n * The door's part of a value key — the activity's name, kebab-cased.\n *\n * ── Why computed and not declared ─────────────────────────────────────────\n * A declared key is a key table, and a key table is what a computed key exists to avoid: nobody\n * writing a new door picks a key, so none of them can be picked wrong, and a test can count every\n * key that exists rather than every key somebody remembered to register.\n *\n * It is safe to hang this on `name` because `name` cannot move — it is the key the callback is\n * found by, and renaming it makes an approval finish with nothing happening. A key derived from a\n * fixed name is fixed.\n *\n * ── The boundary rule ─────────────────────────────────────────────────────\n * Activity names come in two shapes and this repository has both: 'MES Disposition Approval' and\n * 'BatchRelease'. Splitting only on spaces would leave `batchrelease` beside `mes-disposition-\n * approval`; splitting on every capital would turn 'MES' into `m-e-s`. So the split is between a\n * lowercase or digit and a capital, and between a run of capitals and a capitalised word — the same\n * rule `secretEnvName` uses, written after HOOKSECRET and HOOK_SECRET drifted apart.\n */\nexport function doorSlug(activityName: string): string {\n  return String(activityName ?? '')\n    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')\n    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')\n    .replace(/[^A-Za-z0-9]+/g, '-')\n    .toLowerCase()\n    .replace(/^-+|-+$/g, '')\n}\n\n/**\n * The i18n key for one slot's **value sentence** — `approval.<door>.<inputPath>`.\n *\n * `inputPath` and not `role`: a door repeats `consequence`, so two slots in one door would collide\n * on role and the later sentence would silently take the earlier one's key. `inputPath` is the one\n * thing already unique within a door, and it is already written in the declaration.\n */\nexport function decisionValueKey(activityName: string, inputPath: string): string {\n  return `approval.${doorSlug(activityName)}.${inputPath}`\n}\n\n/**\n * The i18n key for an activity's own sentences — `activity.<door>.label`, `activity.<door>.guide.<n>`.\n *\n * Computed from `name` for the reason decisionValueKey is: nobody picks the key, so none is picked\n * wrong, and an app's test can walk its declarations and count every key that must exist.\n *\n * The server sends the result (Activity.labelTKey, InstallableActivity.labelTKey and guideTKeys);\n * screens draw `t(labelTKey, { defaultValue: label })` and never rebuild the slug. A client file that\n * imported this one would move the whole client build under dist-client/client/.\n *\n * `description` has no key. It is the developers' English line and is not shown to the person\n * doing the work.\n *\n * Guide lines are keyed by position. Inserting a line shifts every later translation by one, and a\n * count of keys does not notice — change guide and its translations in the same edit.\n */\nexport function activityTKey(activityName: string, part: 'label' | 'readiness-notes'): string\nexport function activityTKey(activityName: string, part: 'guide' | 'readiness-gap', index: number): string\nexport function activityTKey(\n  activityName: string,\n  part: 'label' | 'guide' | 'readiness-notes' | 'readiness-gap',\n  index?: number\n): string {\n  const door = `activity.${doorSlug(activityName)}`\n\n  switch (part) {\n    case 'guide':\n      return `${door}.guide.${index}`\n    case 'readiness-gap':\n      return `${door}.readiness-gap.${index}`\n    case 'readiness-notes':\n      return `${door}.readiness-notes`\n    default:\n      return `${door}.label`\n  }\n}\n\n/**\n * One key per guide line, **always as many as there are lines.** The screen pairs the two arrays\n * by position; a shorter key list would send the last lines out untranslated with nothing to show it.\n */\nexport function activityGuideTKeys(activityName: string, guide: string[] | undefined | null): string[] {\n  return (guide || []).map((_, index) => activityTKey(activityName, 'guide', index))\n}\n\n/**\n * The same for what a module declares about its own readiness.\n *\n * The catalog screen draws `readiness.gaps` and `readiness.notes` as sentences, and those come out\n * of a catalog that is built at boot, before anyone's locale is known. So the module keeps writing\n * sentences and the screen reads a translation of them, exactly as it does for label and guide\n * (ADR-0054: the sentence is chosen where `context.t` is).\n */\nexport function activityReadinessGapTKeys(activityName: string, gaps: string[] | undefined | null): string[] {\n  return (gaps || []).map((_, index) => activityTKey(activityName, 'readiness-gap', index))\n}\n\nexport function assertDecisionKeysAreUsable(\n  decisionKeys: DecisionKeyDeclaration[] | undefined,\n  activityName?: string\n): void {\n  if (!decisionKeys?.length) {\n    return\n  }\n\n  const named = activityName ? `activity \"${activityName}\"` : 'this activity'\n\n  const unknown = decisionKeys.filter(key => !(DECISION_ROLES as readonly string[]).includes(String(key?.role ?? '')))\n\n  if (unknown.length) {\n    throw new Error(\n      `${named} declares decision keys with a role the approval screen does not know: ` +\n        `${unknown.map(key => `\"${key?.role ?? ''}\"`).join(', ')}. ` +\n        `Known roles are ${DECISION_ROLES.join(', ')}. A role outside that set draws nothing.`\n    )\n  }\n\n  const pathless = decisionKeys.filter(key => !String(key?.inputPath ?? '').trim())\n\n  if (pathless.length) {\n    throw new Error(\n      `${named} declares ${pathless.length} decision key(s) with no inputPath. ` +\n        `A decision key names the value it draws; without a path there is nothing to read.`\n    )\n  }\n\n  /*\n   * An index or a wildcard resolves to nothing at draw time and the slot would report \"the path led\n   * nowhere\" — which reads as a payload that disagrees with the declaration, when the truth is that\n   * the declaration used a path language that does not exist. Refusing here says which it was.\n   */\n  const notPaths = decisionKeys.filter(key => /[[\\]*]/.test(String(key?.inputPath ?? '')))\n\n  if (notPaths.length) {\n    throw new Error(\n      `${named} declares decision keys whose inputPath is not a plain dotted path: ` +\n        `${notPaths.map(key => `\"${key?.inputPath ?? ''}\"`).join(', ')}. ` +\n        `Dots only — no array index and no wildcard. Point at the list itself; drawing its items is ` +\n        `the slot's work.`\n    )\n  }\n\n  const repeated = DECISION_ROLES.filter(\n    role =>\n      !(REPEATABLE_ROLES as readonly string[]).includes(role) &&\n      decisionKeys.filter(key => key?.role === role).length > 1\n  )\n\n  if (repeated.length) {\n    throw new Error(\n      `${named} declares more than one \"${repeated.join('\", \"')}\" decision key. ` +\n        `Only ${REPEATABLE_ROLES.map(role => `\"${role}\"`).join(' and ')} may repeat — an approval can ` +\n        `change several things at once, and grounds come in several. The screen would draw one of the ` +\n        `others and could not say which.`\n    )\n  }\n\n  /*\n   * A sentence may only be built from values that were snapshotted, so every params value is an\n   * inputPath and reads by the same rules. Wanting a value with no field behind it means the field\n   * is missing, not that params needs a second source — the two hold each other up: without the\n   * value the sentence cannot be rebuilt, and a value a sentence uses is guaranteed to stay.\n   *\n   * Only the right side has a rule. The names on the left belong to the sentence and are the\n   * locale file's business.\n   */\n  const badParams: string[] = []\n\n  for (const key of decisionKeys) {\n    for (const [name, path] of Object.entries(key?.params || {})) {\n      const said = String(path ?? '')\n\n      if (!said.trim()) {\n        badParams.push(`\"${name}\" (empty)`)\n      } else if (/[[\\]*]/.test(said)) {\n        badParams.push(`\"${name}\": \"${said}\"`)\n      }\n    }\n  }\n\n  if (badParams.length) {\n    throw new Error(\n      `${named} declares sentence params that are not plain dotted paths into the input: ` +\n        `${badParams.join(', ')}. Every params value is an inputPath — a sentence is built only from ` +\n        `values the request froze, so a value with nowhere to read it from is a missing field.`\n    )\n  }\n\n  if (!activityName) {\n    return\n  }\n\n  /*\n   * The key is computed, so a declared one that disagrees is a typo that would draw `approval.…` on\n   * the card. Checking it here rather than trusting the writer is the whole reason it is computed.\n   */\n  const wrongKey = decisionKeys.filter(\n    key => key?.valueTKey && key.valueTKey !== decisionValueKey(activityName, String(key?.inputPath ?? ''))\n  )\n\n  if (wrongKey.length) {\n    throw new Error(\n      `${named} declares value keys that are not the computed ones: ` +\n        `${wrongKey\n          .map(\n            key => `\"${key?.valueTKey}\" (expected \"${decisionValueKey(activityName, String(key?.inputPath ?? ''))}\")`\n          )\n          .join(', ')}. ` +\n        `The key is approval.<door>.<inputPath> and nobody picks it — a key nobody can pick is a key ` +\n        `nobody can pick wrong.`\n    )\n  }\n}\n"]}

package/dist-server/service/activity/declaration-guard-subscriber.d.ts

@@ -0,0 +1,24 @@
+import { EntitySubscriberInterface, InsertEvent, UpdateEvent } from 'typeorm';
+import { Activity } from './activity.js';
+/**
+ * **One place, because there are five ways in.**
+ *
+ * Activities are saved by createActivity, updateActivity, multipleUpsertActivities, the importer,
+ * and installActivity. A check written at each of those is not a rule — it is five things to
+ * remember, and the sixth way in arrives without it.
+ *
+ * TypeORM's subscriber is the seam every one of them passes through. Throwing here aborts the
+ * transaction, so a refused model is never half-written.
+ *
+ * A template carrying such a field is caught here too: installActivity saves an Activity from it.
+ *
+ * What is refused here are declarations that cannot work — not policy about what an activity may
+ * mean. A credential field cannot be stored, and a sixth search key cannot be indexed; both would
+ * otherwise be accepted, dropped, and reported as saved.
+ */
+export declare class ActivityDeclarationGuardSubscriber implements EntitySubscriberInterface<Activity> {
+    listenTo(): typeof Activity;
+    beforeInsert(event: InsertEvent<Activity>): void;
+    beforeUpdate(event: UpdateEvent<Activity>): void;
+    private assertDeclarable;
+}

package/dist-server/service/activity/declaration-guard-subscriber.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDeclarationGuardSubscriber = void 0;
+const tslib_1 = require("tslib");
+const typeorm_1 = require("typeorm");
+const activity_js_1 = require("./activity.js");
+const credential_field_js_1 = require("./credential-field.js");
+const search_key_declaration_js_1 = require("./search-key-declaration.js");
+const decision_key_declaration_js_1 = require("./decision-key-declaration.js");
+/**
+ * **One place, because there are five ways in.**
+ *
+ * Activities are saved by createActivity, updateActivity, multipleUpsertActivities, the importer,
+ * and installActivity. A check written at each of those is not a rule — it is five things to
+ * remember, and the sixth way in arrives without it.
+ *
+ * TypeORM's subscriber is the seam every one of them passes through. Throwing here aborts the
+ * transaction, so a refused model is never half-written.
+ *
+ * A template carrying such a field is caught here too: installActivity saves an Activity from it.
+ *
+ * What is refused here are declarations that cannot work — not policy about what an activity may
+ * mean. A credential field cannot be stored, and a sixth search key cannot be indexed; both would
+ * otherwise be accepted, dropped, and reported as saved.
+ */
+let ActivityDeclarationGuardSubscriber = class ActivityDeclarationGuardSubscriber {
+    listenTo() {
+        return activity_js_1.Activity;
+    }
+    beforeInsert(event) {
+        this.assertDeclarable(event.entity);
+    }
+    beforeUpdate(event) {
+        this.assertDeclarable(event.entity);
+    }
+    assertDeclarable(activity) {
+        (0, credential_field_js_1.assertNoCredentialField)(activity?.model, activity?.name);
+        (0, search_key_declaration_js_1.assertSearchKeysAreUsable)(activity?.searchKeys, activity?.name);
+        (0, decision_key_declaration_js_1.assertDecisionKeysAreUsable)(activity?.decisionKeys, activity?.name);
+    }
+};
+exports.ActivityDeclarationGuardSubscriber = ActivityDeclarationGuardSubscriber;
+exports.ActivityDeclarationGuardSubscriber = ActivityDeclarationGuardSubscriber = tslib_1.__decorate([
+    (0, typeorm_1.EventSubscriber)()
+], ActivityDeclarationGuardSubscriber);
+//# sourceMappingURL=declaration-guard-subscriber.js.map

package/dist-server/service/activity/declaration-guard-subscriber.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"declaration-guard-subscriber.js","sourceRoot":"","sources":["../../../server/service/activity/declaration-guard-subscriber.ts"],"names":[],"mappings":";;;;AAAA,qCAA8F;AAE9F,+CAAwC;AACxC,+DAA+D;AAC/D,2EAAuE;AACvE,+EAA2E;AAE3E;;;;;;;;;;;;;;;GAeG;AAEI,IAAM,kCAAkC,GAAxC,MAAM,kCAAkC;IAC7C,QAAQ;QACN,OAAO,sBAAQ,CAAA;IACjB,CAAC;IAED,YAAY,CAAC,KAA4B;QACvC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IACrC,CAAC;IAED,YAAY,CAAC,KAA4B;QACvC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,MAAkB,CAAC,CAAA;IACjD,CAAC;IAEO,gBAAgB,CAAC,QAAmB;QAC1C,IAAA,6CAAuB,EAAC,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAA;QACxD,IAAA,qDAAyB,EAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAA;QAC/D,IAAA,yDAA2B,EAAC,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAA;IACrE,CAAC;CACF,CAAA;AAlBY,gFAAkC;6CAAlC,kCAAkC;IAD9C,IAAA,yBAAe,GAAE;GACL,kCAAkC,CAkB9C","sourcesContent":["import { EntitySubscriberInterface, EventSubscriber, InsertEvent, UpdateEvent } from 'typeorm'\n\nimport { Activity } from './activity.js'\nimport { assertNoCredentialField } from './credential-field.js'\nimport { assertSearchKeysAreUsable } from './search-key-declaration.js'\nimport { assertDecisionKeysAreUsable } from './decision-key-declaration.js'\n\n/**\n * **One place, because there are five ways in.**\n *\n * Activities are saved by createActivity, updateActivity, multipleUpsertActivities, the importer,\n * and installActivity. A check written at each of those is not a rule — it is five things to\n * remember, and the sixth way in arrives without it.\n *\n * TypeORM's subscriber is the seam every one of them passes through. Throwing here aborts the\n * transaction, so a refused model is never half-written.\n *\n * A template carrying such a field is caught here too: installActivity saves an Activity from it.\n *\n * What is refused here are declarations that cannot work — not policy about what an activity may\n * mean. A credential field cannot be stored, and a sixth search key cannot be indexed; both would\n * otherwise be accepted, dropped, and reported as saved.\n */\n@EventSubscriber()\nexport class ActivityDeclarationGuardSubscriber implements EntitySubscriberInterface<Activity> {\n  listenTo() {\n    return Activity\n  }\n\n  beforeInsert(event: InsertEvent<Activity>) {\n    this.assertDeclarable(event.entity)\n  }\n\n  beforeUpdate(event: UpdateEvent<Activity>) {\n    this.assertDeclarable(event.entity as Activity)\n  }\n\n  private assertDeclarable(activity?: Activity) {\n    assertNoCredentialField(activity?.model, activity?.name)\n    assertSearchKeysAreUsable(activity?.searchKeys, activity?.name)\n    assertDecisionKeysAreUsable(activity?.decisionKeys, activity?.name)\n  }\n}\n"]}

package/dist-server/service/activity/event-subscriber.d.ts

@@ -0,0 +1,7 @@
+import { HistoryEntitySubscriber } from '@operato/typeorm-history';
+import { Activity } from './activity.js';
+import { ActivityHistory } from './activity-history.js';
+export declare class ActivityHistoryEntitySubscriber extends HistoryEntitySubscriber<Activity, ActivityHistory> {
+    get entity(): typeof Activity;
+    get historyEntity(): typeof ActivityHistory;
+}

package/dist-server/service/activity/event-subscriber.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityHistoryEntitySubscriber = void 0;
+const tslib_1 = require("tslib");
+const typeorm_1 = require("typeorm");
+const typeorm_history_1 = require("@operato/typeorm-history");
+const activity_js_1 = require("./activity.js");
+const activity_history_js_1 = require("./activity-history.js");
+let ActivityHistoryEntitySubscriber = class ActivityHistoryEntitySubscriber extends typeorm_history_1.HistoryEntitySubscriber {
+    get entity() {
+        return activity_js_1.Activity;
+    }
+    get historyEntity() {
+        return activity_history_js_1.ActivityHistory;
+    }
+};
+exports.ActivityHistoryEntitySubscriber = ActivityHistoryEntitySubscriber;
+exports.ActivityHistoryEntitySubscriber = ActivityHistoryEntitySubscriber = tslib_1.__decorate([
+    (0, typeorm_1.EventSubscriber)()
+], ActivityHistoryEntitySubscriber);
+//# sourceMappingURL=event-subscriber.js.map

package/dist-server/service/activity/event-subscriber.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-subscriber.js","sourceRoot":"","sources":["../../../server/service/activity/event-subscriber.ts"],"names":[],"mappings":";;;;AAAA,qCAAyC;AAEzC,8DAAkE;AAElE,+CAAwC;AACxC,+DAAuD;AAGhD,IAAM,+BAA+B,GAArC,MAAM,+BAAgC,SAAQ,yCAAkD;IACrG,IAAW,MAAM;QACf,OAAO,sBAAQ,CAAA;IACjB,CAAC;IAED,IAAW,aAAa;QACtB,OAAO,qCAAe,CAAA;IACxB,CAAC;CAEF,CAAA;AATY,0EAA+B;0CAA/B,+BAA+B;IAD3C,IAAA,yBAAe,GAAE;GACL,+BAA+B,CAS3C","sourcesContent":["import { EventSubscriber } from 'typeorm'\n\nimport { HistoryEntitySubscriber } from '@operato/typeorm-history'\n\nimport { Activity } from './activity.js'\nimport { ActivityHistory } from './activity-history.js'\n\n@EventSubscriber()\nexport class ActivityHistoryEntitySubscriber extends HistoryEntitySubscriber<Activity, ActivityHistory> {\n  public get entity() {\n    return Activity\n  }\n\n  public get historyEntity() {\n    return ActivityHistory\n  }\n\n}\n"]}

package/dist-server/service/activity/freeze-decision-sentences-for.d.ts

@@ -0,0 +1,11 @@
+import type { DecisionSentenceKey } from '../../../shared/decision-sentences.js';
+/**
+ * An approval input with its value sentences frozen **in one language**, read from the server's translations.
+ *
+ * ── Why here (2026-10-11, chief architect ruling) ──────────────────────────
+ * plant and then warehouse each wrote the same line — `freezeDecisionSentences(keys, input, translatorFor('ko'),
+ * 'ko')` — in a helper of their own. Two copies of one rule is what this module exists to stop, so the line lives
+ * here and the applications call it. The translator does not fall back to another language: a sentence missing in
+ * `locale` refuses the raise (`DecisionSentenceMissing`) instead of filing another language's sentence.
+ */
+export declare function freezeDecisionSentencesFor<T>(decisionKeys: DecisionSentenceKey[] | null | undefined, input: T, locale: string): T;

package/dist-server/service/activity/freeze-decision-sentences-for.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.freezeDecisionSentencesFor = freezeDecisionSentencesFor;
+const translator_1 = require("@things-factory/i18n-base/translator");
+const decision_sentences_js_1 = require("../../../shared/decision-sentences.js");
+/**
+ * An approval input with its value sentences frozen **in one language**, read from the server's translations.
+ *
+ * ── Why here (2026-10-11, chief architect ruling) ──────────────────────────
+ * plant and then warehouse each wrote the same line — `freezeDecisionSentences(keys, input, translatorFor('ko'),
+ * 'ko')` — in a helper of their own. Two copies of one rule is what this module exists to stop, so the line lives
+ * here and the applications call it. The translator does not fall back to another language: a sentence missing in
+ * `locale` refuses the raise (`DecisionSentenceMissing`) instead of filing another language's sentence.
+ */
+function freezeDecisionSentencesFor(decisionKeys, input, locale) {
+    return (0, decision_sentences_js_1.freezeDecisionSentences)(decisionKeys, input, (0, translator_1.translatorFor)(locale), locale);
+}
+//# sourceMappingURL=freeze-decision-sentences-for.js.map

package/dist-server/service/activity/freeze-decision-sentences-for.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"freeze-decision-sentences-for.js","sourceRoot":"","sources":["../../../server/service/activity/freeze-decision-sentences-for.ts"],"names":[],"mappings":";;AAcA,gEAMC;AApBD,qEAAoE;AAEpE,iFAA+E;AAG/E;;;;;;;;GAQG;AACH,SAAgB,0BAA0B,CACxC,YAAsD,EACtD,KAAQ,EACR,MAAc;IAEd,OAAO,IAAA,+CAAuB,EAAC,YAAY,EAAE,KAAK,EAAE,IAAA,0BAAa,EAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAA;AACpF,CAAC","sourcesContent":["import { translatorFor } from '@things-factory/i18n-base/translator'\n\nimport { freezeDecisionSentences } from '../../../shared/decision-sentences.js'\nimport type { DecisionSentenceKey } from '../../../shared/decision-sentences.js'\n\n/**\n * An approval input with its value sentences frozen **in one language**, read from the server's translations.\n *\n * ── Why here (2026-10-11, chief architect ruling) ──────────────────────────\n * plant and then warehouse each wrote the same line — `freezeDecisionSentences(keys, input, translatorFor('ko'),\n * 'ko')` — in a helper of their own. Two copies of one rule is what this module exists to stop, so the line lives\n * here and the applications call it. The translator does not fall back to another language: a sentence missing in\n * `locale` refuses the raise (`DecisionSentenceMissing`) instead of filing another language's sentence.\n */\nexport function freezeDecisionSentencesFor<T>(\n  decisionKeys: DecisionSentenceKey[] | null | undefined,\n  input: T,\n  locale: string\n): T {\n  return freezeDecisionSentences(decisionKeys, input, translatorFor(locale), locale)\n}\n"]}

package/dist-server/service/activity/index.d.ts

@@ -0,0 +1,9 @@
+import { Activity } from "./activity.js";
+import { ActivityHistory } from "./activity-history.js";
+import { ActivityMutation } from "./activity-mutation.js";
+import { ActivityQuery } from "./activity-query.js";
+import { ActivityHistoryEntitySubscriber } from "./event-subscriber.js";
+import { ActivityDeclarationGuardSubscriber } from "./declaration-guard-subscriber.js";
+export declare const entities: (typeof Activity | typeof ActivityHistory)[];
+export declare const resolvers: (typeof ActivityMutation | typeof ActivityQuery)[];
+export declare const subscribers: (typeof ActivityHistoryEntitySubscriber | typeof ActivityDeclarationGuardSubscriber)[];

package/dist-server/service/activity/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribers = exports.resolvers = exports.entities = void 0;
+const activity_js_1 = require("./activity.js");
+const activity_history_js_1 = require("./activity-history.js");
+const activity_mutation_js_1 = require("./activity-mutation.js");
+const activity_query_js_1 = require("./activity-query.js");
+const event_subscriber_js_1 = require("./event-subscriber.js");
+const declaration_guard_subscriber_js_1 = require("./declaration-guard-subscriber.js");
+exports.entities = [activity_js_1.Activity, activity_history_js_1.ActivityHistory];
+exports.resolvers = [activity_query_js_1.ActivityQuery, activity_mutation_js_1.ActivityMutation];
+exports.subscribers = [event_subscriber_js_1.ActivityHistoryEntitySubscriber, declaration_guard_subscriber_js_1.ActivityDeclarationGuardSubscriber];
+//# sourceMappingURL=index.js.map

package/dist-server/service/activity/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../server/service/activity/index.ts"],"names":[],"mappings":";;;AAAA,+CAAwC;AACxC,+DAAuD;AACvD,iEAAyD;AACzD,2DAAmD;AACnD,+DAAuE;AACvE,uFAAsF;AAEzE,QAAA,QAAQ,GAAG,CAAC,sBAAQ,EAAE,qCAAe,CAAC,CAAA;AACtC,QAAA,SAAS,GAAG,CAAC,iCAAa,EAAE,uCAAgB,CAAC,CAAA;AAC7C,QAAA,WAAW,GAAG,CAAC,qDAA+B,EAAE,oEAAkC,CAAC,CAAA","sourcesContent":["import { Activity } from \"./activity.js\"\nimport { ActivityHistory } from \"./activity-history.js\"\nimport { ActivityMutation } from \"./activity-mutation.js\"\nimport { ActivityQuery } from \"./activity-query.js\"\nimport { ActivityHistoryEntitySubscriber } from \"./event-subscriber.js\"\nimport { ActivityDeclarationGuardSubscriber } from \"./declaration-guard-subscriber.js\"\n\nexport const entities = [Activity, ActivityHistory]\nexport const resolvers = [ActivityQuery, ActivityMutation]\nexport const subscribers = [ActivityHistoryEntitySubscriber, ActivityDeclarationGuardSubscriber]\n"]}

package/dist-server/service/activity/search-key-declaration.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The shape this rule needs, spelled out rather than imported.
+ *
+ * ActivitySearchKeyItem carries type-graphql decorators, and the test runner parses TypeScript by
+ * stripping types — it reads neither a decorator nor an enum. Importing the declared class pulls
+ * type-graphql in and the whole test file fails to load, which is what happened when this module
+ * first imported it (2026-09-09). A rule about a field's text needs only the field.
+ */
+type SearchKeyDeclaration = {
+    inputKey?: string;
+};
+/**
+ * How many search keys an activity may declare.
+ *
+ * fillActivitySearchKeys writes each one to `key0${index + 1}` on the instance, and the instance has
+ * key01 through key05 — five columns, no more. The function has no ceiling, so a sixth key writes to
+ * key06, a column that does not exist. A spread save drops a field it does not recognise and reports
+ * success, which means the declaration looks accepted, the value is never stored, and searching on
+ * that axis answers zero rows with no error anywhere.
+ *
+ * Nothing declares six today: twelve declarations across four repositories, the largest three
+ * (measured 2026-09-09). This refusal is what keeps the seventh one from being the first to find
+ * out.
+ */
+export declare const MOST_SEARCH_KEYS = 5;
+/**
+ * Why a dotted key cannot work here.
+ *
+ * fillActivitySearchKeys reads `input[key.inputKey]` — one top-level key, and an array is indexed by
+ * its first element because the value goes into a searchable column. A dot in that name looks up a
+ * property literally called "shift.passes", finds nothing, and the axis is quietly left unfilled.
+ *
+ * ActivityDecisionKeyItem.inputPath is the field that does take a path, because it points at a value
+ * to draw rather than one to index. The two names are different so that using the wrong one is
+ * visible rather than silent. (2026-09-09, architect's ruling)
+ */
+export declare function assertSearchKeysAreUsable(searchKeys: SearchKeyDeclaration[] | undefined, activityName?: string): void;
+export {};

package/dist-server/service/activity/search-key-declaration.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOST_SEARCH_KEYS = void 0;
+exports.assertSearchKeysAreUsable = assertSearchKeysAreUsable;
+/**
+ * How many search keys an activity may declare.
+ *
+ * fillActivitySearchKeys writes each one to `key0${index + 1}` on the instance, and the instance has
+ * key01 through key05 — five columns, no more. The function has no ceiling, so a sixth key writes to
+ * key06, a column that does not exist. A spread save drops a field it does not recognise and reports
+ * success, which means the declaration looks accepted, the value is never stored, and searching on
+ * that axis answers zero rows with no error anywhere.
+ *
+ * Nothing declares six today: twelve declarations across four repositories, the largest three
+ * (measured 2026-09-09). This refusal is what keeps the seventh one from being the first to find
+ * out.
+ */
+exports.MOST_SEARCH_KEYS = 5;
+/**
+ * Why a dotted key cannot work here.
+ *
+ * fillActivitySearchKeys reads `input[key.inputKey]` — one top-level key, and an array is indexed by
+ * its first element because the value goes into a searchable column. A dot in that name looks up a
+ * property literally called "shift.passes", finds nothing, and the axis is quietly left unfilled.
+ *
+ * ActivityDecisionKeyItem.inputPath is the field that does take a path, because it points at a value
+ * to draw rather than one to index. The two names are different so that using the wrong one is
+ * visible rather than silent. (2026-09-09, architect's ruling)
+ */
+function assertSearchKeysAreUsable(searchKeys, activityName) {
+    if (!searchKeys?.length) {
+        return;
+    }
+    const named = activityName ? `activity "${activityName}"` : 'this activity';
+    if (searchKeys.length > exports.MOST_SEARCH_KEYS) {
+        throw new Error(`${named} declares ${searchKeys.length} search keys, and an activity instance has only ` +
+            `${exports.MOST_SEARCH_KEYS} columns to hold them (key01..key0${exports.MOST_SEARCH_KEYS}). ` +
+            `Keys past the ${exports.MOST_SEARCH_KEYS}th would be dropped without an error and searching on ` +
+            `them would answer zero rows.`);
+    }
+    const dotted = searchKeys.filter(key => String(key?.inputKey ?? '').includes('.'));
+    if (dotted.length) {
+        throw new Error(`${named} declares search keys whose inputKey holds a path: ` +
+            `${dotted.map(key => `"${key.inputKey}"`).join(', ')}. ` +
+            `A search key names one top-level key of the input, because its value goes into a searchable ` +
+            `column. Use ActivityDecisionKeyItem.inputPath for a value nested inside the input.`);
+    }
+}
+//# sourceMappingURL=search-key-declaration.js.map

package/dist-server/service/activity/search-key-declaration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-key-declaration.js","sourceRoot":"","sources":["../../../server/service/activity/search-key-declaration.ts"],"names":[],"mappings":";;;AAoCA,8DA0BC;AApDD;;;;;;;;;;;;GAYG;AACU,QAAA,gBAAgB,GAAG,CAAC,CAAA;AAEjC;;;;;;;;;;GAUG;AACH,SAAgB,yBAAyB,CAAC,UAA8C,EAAE,YAAqB;IAC7G,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,CAAC;QACxB,OAAM;IACR,CAAC;IAED,MAAM,KAAK,GAAG,YAAY,CAAC,CAAC,CAAC,aAAa,YAAY,GAAG,CAAC,CAAC,CAAC,eAAe,CAAA;IAE3E,IAAI,UAAU,CAAC,MAAM,GAAG,wBAAgB,EAAE,CAAC;QACzC,MAAM,IAAI,KAAK,CACb,GAAG,KAAK,aAAa,UAAU,CAAC,MAAM,kDAAkD;YACtF,GAAG,wBAAgB,qCAAqC,wBAAgB,KAAK;YAC7E,iBAAiB,wBAAgB,wDAAwD;YACzF,8BAA8B,CACjC,CAAA;IACH,CAAC;IAED,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAA;IAElF,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;QAClB,MAAM,IAAI,KAAK,CACb,GAAG,KAAK,qDAAqD;YAC3D,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,GAAG,CAAC,QAAQ,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;YACxD,8FAA8F;YAC9F,oFAAoF,CACvF,CAAA;IACH,CAAC;AACH,CAAC","sourcesContent":["/**\n * The shape this rule needs, spelled out rather than imported.\n *\n * ActivitySearchKeyItem carries type-graphql decorators, and the test runner parses TypeScript by\n * stripping types — it reads neither a decorator nor an enum. Importing the declared class pulls\n * type-graphql in and the whole test file fails to load, which is what happened when this module\n * first imported it (2026-09-09). A rule about a field's text needs only the field.\n */\ntype SearchKeyDeclaration = { inputKey?: string }\n\n/**\n * How many search keys an activity may declare.\n *\n * fillActivitySearchKeys writes each one to `key0${index + 1}` on the instance, and the instance has\n * key01 through key05 — five columns, no more. The function has no ceiling, so a sixth key writes to\n * key06, a column that does not exist. A spread save drops a field it does not recognise and reports\n * success, which means the declaration looks accepted, the value is never stored, and searching on\n * that axis answers zero rows with no error anywhere.\n *\n * Nothing declares six today: twelve declarations across four repositories, the largest three\n * (measured 2026-09-09). This refusal is what keeps the seventh one from being the first to find\n * out.\n */\nexport const MOST_SEARCH_KEYS = 5\n\n/**\n * Why a dotted key cannot work here.\n *\n * fillActivitySearchKeys reads `input[key.inputKey]` — one top-level key, and an array is indexed by\n * its first element because the value goes into a searchable column. A dot in that name looks up a\n * property literally called \"shift.passes\", finds nothing, and the axis is quietly left unfilled.\n *\n * ActivityDecisionKeyItem.inputPath is the field that does take a path, because it points at a value\n * to draw rather than one to index. The two names are different so that using the wrong one is\n * visible rather than silent. (2026-09-09, architect's ruling)\n */\nexport function assertSearchKeysAreUsable(searchKeys: SearchKeyDeclaration[] | undefined, activityName?: string): void {\n  if (!searchKeys?.length) {\n    return\n  }\n\n  const named = activityName ? `activity \"${activityName}\"` : 'this activity'\n\n  if (searchKeys.length > MOST_SEARCH_KEYS) {\n    throw new Error(\n      `${named} declares ${searchKeys.length} search keys, and an activity instance has only ` +\n        `${MOST_SEARCH_KEYS} columns to hold them (key01..key0${MOST_SEARCH_KEYS}). ` +\n        `Keys past the ${MOST_SEARCH_KEYS}th would be dropped without an error and searching on ` +\n        `them would answer zero rows.`\n    )\n  }\n\n  const dotted = searchKeys.filter(key => String(key?.inputKey ?? '').includes('.'))\n\n  if (dotted.length) {\n    throw new Error(\n      `${named} declares search keys whose inputKey holds a path: ` +\n        `${dotted.map(key => `\"${key.inputKey}\"`).join(', ')}. ` +\n        `A search key names one top-level key of the input, because its value goes into a searchable ` +\n        `column. Use ActivityDecisionKeyItem.inputPath for a value nested inside the input.`\n    )\n  }\n}\n"]}

package/dist-server/service/activity-approval/activity-approval-mutation.d.ts

@@ -0,0 +1,8 @@
+import { ObjectRef } from '@things-factory/shell';
+import { ActivityApproval } from './activity-approval.js';
+export declare class ActivityApprovalMutation {
+    saveActivityApproval(id: string, comment: string, context: ResolverContext): Promise<ActivityApproval>;
+    approveActivityApproval(id: string, comment: string, context: ResolverContext): Promise<ActivityApproval>;
+    rejectActivityApproval(id: string, comment: string, context: ResolverContext): Promise<ActivityApproval>;
+    delegateActivityApproval(id: string, to: ObjectRef, comment: string, context: ResolverContext): Promise<ActivityApproval>;
+}