@webiny/api-workflows 0.0.0-unstable.81ae05e56b → 0.0.0-unstable.9609e4e0c9

package/domain/routing/errors.js

@@ -0,0 +1,18 @@
+import { PersistenceError } from "../PersistenceError.js";
+class RoutingDependencyError extends PersistenceError {
+    constructor(error, decided = null){
+        super("A lookup needed for routing failed.", error, error instanceof RoutingDependencyError ? error.data.cause.code : error.code), this.code = "Workflows/Routing/Dependency";
+        this.decided = decided ? {
+            candidateTeamIds: [
+                ...decided.candidateTeamIds
+            ],
+            ruleId: decided.ruleId,
+            skips: decided.skips.map((skip)=>({
+                    ...skip
+                }))
+        } : null;
+    }
+}
+export { RoutingDependencyError };
+
+//# sourceMappingURL=errors.js.map

package/domain/routing/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/errors.js","sources":["../../../src/domain/routing/errors.ts"],"sourcesContent":["import type { AssignmentDecision } from \"~/domain/assignment/types.js\";\nimport type { PersistenceErrorSource } from \"~/domain/PersistenceErrorSource.js\";\nimport { PersistenceError } from \"~/domain/PersistenceError.js\";\n\n/**\n * What step-reach evaluation had decided when a lookup failed (R116 refined): the candidate\n * teams (narrowed when a team-target rule matched, else the step's teams), that rule, and the\n * skip records gathered so far, in decision order. The resolver's pool keeps them.\n */\nexport interface RoutingDecidedSoFar {\n    candidateTeamIds: string[];\n    ruleId: string | null;\n    skips: AssignmentDecision[];\n}\n\n/**\n * A lookup routing needs failed: users, settings, the folder chain or a strategy's history\n * (R116). The resolver turns it into the pool; the inspector and candidate lists report it.\n * `decided` is set by step-reach evaluation and is not part of `data`: skip records never travel\n * on an error payload.\n */\nexport class RoutingDependencyError extends PersistenceError {\n    override readonly code = \"Workflows/Routing/Dependency\" as const;\n    public readonly decided: RoutingDecidedSoFar | null;\n\n    /** Pass another `RoutingDependencyError` to keep its cause and add what was decided. */\n    constructor(\n        error: PersistenceErrorSource | RoutingDependencyError,\n        decided: RoutingDecidedSoFar | null = null\n    ) {\n        // Another routing error passes on the cause it reports, other persistence errors their own\n        // code.\n        super(\n            \"A lookup needed for routing failed.\",\n            error,\n            error instanceof RoutingDependencyError ? error.data.cause.code : error.code\n        );\n        this.decided = decided\n            ? {\n                  candidateTeamIds: [...decided.candidateTeamIds],\n                  ruleId: decided.ruleId,\n                  skips: decided.skips.map(skip => ({ ...skip }))\n              }\n            : null;\n    }\n}\n"],"names":["RoutingDependencyError","PersistenceError","error","decided","skip"],"mappings":";AAqBO,MAAMA,+BAA+BC;IAKxC,YACIC,KAAsD,EACtDC,UAAsC,IAAI,CAC5C;QAGE,KAAK,CACD,uCACAD,OACAA,iBAAiBF,yBAAyBE,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,GAAGA,MAAM,IAAI,QAblE,IAAI,GAAG;QAerB,IAAI,CAAC,OAAO,GAAGC,UACT;YACI,kBAAkB;mBAAIA,QAAQ,gBAAgB;aAAC;YAC/C,QAAQA,QAAQ,MAAM;YACtB,OAAOA,QAAQ,KAAK,CAAC,GAAG,CAACC,CAAAA,OAAS;oBAAE,GAAGA,IAAI;gBAAC;QAChD,IACA;IACV;AACJ"}

package/domain/routing/findNarrowedTeamId.d.ts

@@ -0,0 +1,5 @@
+import type { RoutingRule } from "../../domain/workflow/types.js";
+/**
+ * The team a matched team-target rule narrowed the candidates to; null for any other rule. Pure.
+ */
+export declare const findNarrowedTeamId: (rules: RoutingRule[], ruleId: string | null) => string | null;

package/domain/routing/findNarrowedTeamId.js

@@ -0,0 +1,8 @@
+const findNarrowedTeamId = (rules, ruleId)=>{
+    const rule = rules.find((item)=>item.id === ruleId);
+    if (rule && "team" === rule.target.type) return rule.target.id;
+    return null;
+};
+export { findNarrowedTeamId };
+
+//# sourceMappingURL=findNarrowedTeamId.js.map

package/domain/routing/findNarrowedTeamId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/findNarrowedTeamId.js","sources":["../../../src/domain/routing/findNarrowedTeamId.ts"],"sourcesContent":["import type { RoutingRule } from \"~/domain/workflow/types.js\";\n\n/**\n * The team a matched team-target rule narrowed the candidates to; null for any other rule. Pure.\n */\nexport const findNarrowedTeamId = (rules: RoutingRule[], ruleId: string | null): string | null => {\n    const rule = rules.find(item => item.id === ruleId);\n    if (rule && rule.target.type === \"team\") {\n        return rule.target.id;\n    }\n    return null;\n};\n"],"names":["findNarrowedTeamId","rules","ruleId","rule","item"],"mappings":"AAKO,MAAMA,qBAAqB,CAACC,OAAsBC;IACrD,MAAMC,OAAOF,MAAM,IAAI,CAACG,CAAAA,OAAQA,KAAK,EAAE,KAAKF;IAC5C,IAAIC,QAAQA,AAAqB,WAArBA,KAAK,MAAM,CAAC,IAAI,EACxB,OAAOA,KAAK,MAAM,CAAC,EAAE;IAEzB,OAAO;AACX"}

package/domain/routing/getFailedRoutingConditions.d.ts

@@ -0,0 +1,10 @@
+import type { RoutingRuleConditions } from "../../domain/workflow/types.js";
+import type { RoutingCondition, RoutingRuleFacts } from "./types.js";
+/**
+ * The conditions of a rule that do not hold, in the order requester, requester's team, folder
+ * (R289). Pure; the facts must carry the requester's teams and the folder chain, so the inspector
+ * reads them for every rule it explains. A failed `modelId` condition names nothing here: it
+ * fails the rule (`matchRoutingRuleConditions`) but the editor has no such condition. Uses the
+ * same per-condition predicates as `matchRoutingRuleConditions`.
+ */
+export declare const getFailedRoutingConditions: (conditions: RoutingRuleConditions, facts: RoutingRuleFacts) => RoutingCondition[];

package/domain/routing/getFailedRoutingConditions.js

@@ -0,0 +1,13 @@
+import { matchesRequesterUserCondition } from "./matchesRequesterUserCondition.js";
+import { matchesRequesterTeamCondition } from "./matchesRequesterTeamCondition.js";
+import { matchesFolderCondition } from "./matchesFolderCondition.js";
+const getFailedRoutingConditions = (conditions, facts)=>{
+    const failed = [];
+    if (!matchesRequesterUserCondition(conditions, facts)) failed.push("requesterUser");
+    if (!matchesRequesterTeamCondition(conditions, facts)) failed.push("requesterTeam");
+    if (!matchesFolderCondition(conditions, facts)) failed.push("folder");
+    return failed;
+};
+export { getFailedRoutingConditions };
+
+//# sourceMappingURL=getFailedRoutingConditions.js.map

package/domain/routing/getFailedRoutingConditions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/getFailedRoutingConditions.js","sources":["../../../src/domain/routing/getFailedRoutingConditions.ts"],"sourcesContent":["import type { RoutingRuleConditions } from \"~/domain/workflow/types.js\";\nimport type { RoutingCondition, RoutingRuleFacts } from \"./types.js\";\nimport { matchesRequesterUserCondition } from \"./matchesRequesterUserCondition.js\";\nimport { matchesRequesterTeamCondition } from \"./matchesRequesterTeamCondition.js\";\nimport { matchesFolderCondition } from \"./matchesFolderCondition.js\";\n\n/**\n * The conditions of a rule that do not hold, in the order requester, requester's team, folder\n * (R289). Pure; the facts must carry the requester's teams and the folder chain, so the inspector\n * reads them for every rule it explains. A failed `modelId` condition names nothing here: it\n * fails the rule (`matchRoutingRuleConditions`) but the editor has no such condition. Uses the\n * same per-condition predicates as `matchRoutingRuleConditions`.\n */\nexport const getFailedRoutingConditions = (\n    conditions: RoutingRuleConditions,\n    facts: RoutingRuleFacts\n): RoutingCondition[] => {\n    const failed: RoutingCondition[] = [];\n    if (!matchesRequesterUserCondition(conditions, facts)) {\n        failed.push(\"requesterUser\");\n    }\n    if (!matchesRequesterTeamCondition(conditions, facts)) {\n        failed.push(\"requesterTeam\");\n    }\n    if (!matchesFolderCondition(conditions, facts)) {\n        failed.push(\"folder\");\n    }\n    return failed;\n};\n"],"names":["getFailedRoutingConditions","conditions","facts","failed","matchesRequesterUserCondition","matchesRequesterTeamCondition","matchesFolderCondition"],"mappings":";;;AAaO,MAAMA,6BAA6B,CACtCC,YACAC;IAEA,MAAMC,SAA6B,EAAE;IACrC,IAAI,CAACC,8BAA8BH,YAAYC,QAC3CC,OAAO,IAAI,CAAC;IAEhB,IAAI,CAACE,8BAA8BJ,YAAYC,QAC3CC,OAAO,IAAI,CAAC;IAEhB,IAAI,CAACG,uBAAuBL,YAAYC,QACpCC,OAAO,IAAI,CAAC;IAEhB,OAAOA;AACX"}

package/domain/routing/getRoutingUserSkipReason.d.ts

@@ -0,0 +1,16 @@
+import type { WorkflowExclusion } from "../../domain/settings/types.js";
+import { type RoutingSkipReason } from "./reasons.js";
+export interface RoutingUserEligibilityParams {
+    userId: string;
+    requesterId: string;
+    /** Members of the candidate teams. */
+    memberIds: string[];
+    /** Active exclusions only (`filterActiveExclusions`). */
+    exclusions: WorkflowExclusion[];
+}
+/**
+ * Why a person target cannot get the step, before the read check (R112): the requester, then
+ * membership, then exclusion. The requester comes first, so a requester outside the step's teams
+ * gets the requester reason. `null` when they pass; the caller checks read access next. Pure.
+ */
+export declare const getRoutingUserSkipReason: (params: RoutingUserEligibilityParams) => RoutingSkipReason | null;

package/domain/routing/getRoutingUserSkipReason.js

@@ -0,0 +1,10 @@
+import { ROUTING_SKIP_REASONS } from "./reasons.js";
+const getRoutingUserSkipReason = (params)=>{
+    if (params.userId === params.requesterId) return ROUTING_SKIP_REASONS.requester;
+    if (!params.memberIds.includes(params.userId)) return ROUTING_SKIP_REASONS.notMember;
+    if (params.exclusions.some((exclusion)=>exclusion.userId === params.userId)) return ROUTING_SKIP_REASONS.excluded;
+    return null;
+};
+export { getRoutingUserSkipReason };
+
+//# sourceMappingURL=getRoutingUserSkipReason.js.map

package/domain/routing/getRoutingUserSkipReason.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/getRoutingUserSkipReason.js","sources":["../../../src/domain/routing/getRoutingUserSkipReason.ts"],"sourcesContent":["import type { WorkflowExclusion } from \"~/domain/settings/types.js\";\nimport { ROUTING_SKIP_REASONS, type RoutingSkipReason } from \"./reasons.js\";\n\nexport interface RoutingUserEligibilityParams {\n    userId: string;\n    requesterId: string;\n    /** Members of the candidate teams. */\n    memberIds: string[];\n    /** Active exclusions only (`filterActiveExclusions`). */\n    exclusions: WorkflowExclusion[];\n}\n\n/**\n * Why a person target cannot get the step, before the read check (R112): the requester, then\n * membership, then exclusion. The requester comes first, so a requester outside the step's teams\n * gets the requester reason. `null` when they pass; the caller checks read access next. Pure.\n */\nexport const getRoutingUserSkipReason = (\n    params: RoutingUserEligibilityParams\n): RoutingSkipReason | null => {\n    if (params.userId === params.requesterId) {\n        return ROUTING_SKIP_REASONS.requester;\n    }\n    if (!params.memberIds.includes(params.userId)) {\n        return ROUTING_SKIP_REASONS.notMember;\n    }\n    if (params.exclusions.some(exclusion => exclusion.userId === params.userId)) {\n        return ROUTING_SKIP_REASONS.excluded;\n    }\n    return null;\n};\n"],"names":["getRoutingUserSkipReason","params","ROUTING_SKIP_REASONS","exclusion"],"mappings":";AAiBO,MAAMA,2BAA2B,CACpCC;IAEA,IAAIA,OAAO,MAAM,KAAKA,OAAO,WAAW,EACpC,OAAOC,qBAAqB,SAAS;IAEzC,IAAI,CAACD,OAAO,SAAS,CAAC,QAAQ,CAACA,OAAO,MAAM,GACxC,OAAOC,qBAAqB,SAAS;IAEzC,IAAID,OAAO,UAAU,CAAC,IAAI,CAACE,CAAAA,YAAaA,UAAU,MAAM,KAAKF,OAAO,MAAM,GACtE,OAAOC,qBAAqB,QAAQ;IAExC,OAAO;AACX"}

package/domain/routing/listNotEvaluatedTrace.d.ts

@@ -0,0 +1,7 @@
+import type { RoutingRule } from "../../domain/workflow/types.js";
+import type { RoutingTraceEntry } from "./types.js";
+/**
+ * The trace entries of the rules from `fromIndex` on, after the rule that decided (R289): outcome
+ * `notEvaluated`, no reason, no failed conditions. Pure.
+ */
+export declare const listNotEvaluatedTrace: (rules: RoutingRule[], fromIndex: number) => RoutingTraceEntry[];

package/domain/routing/listNotEvaluatedTrace.js

@@ -0,0 +1,9 @@
+const listNotEvaluatedTrace = (rules, fromIndex)=>rules.slice(fromIndex).map((rule)=>({
+            ruleId: rule.id,
+            outcome: "notEvaluated",
+            reason: null,
+            failedConditions: []
+        }));
+export { listNotEvaluatedTrace };
+
+//# sourceMappingURL=listNotEvaluatedTrace.js.map

package/domain/routing/listNotEvaluatedTrace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/listNotEvaluatedTrace.js","sources":["../../../src/domain/routing/listNotEvaluatedTrace.ts"],"sourcesContent":["import type { RoutingRule } from \"~/domain/workflow/types.js\";\nimport type { RoutingTraceEntry } from \"./types.js\";\n\n/**\n * The trace entries of the rules from `fromIndex` on, after the rule that decided (R289): outcome\n * `notEvaluated`, no reason, no failed conditions. Pure.\n */\nexport const listNotEvaluatedTrace = (\n    rules: RoutingRule[],\n    fromIndex: number\n): RoutingTraceEntry[] => {\n    return rules.slice(fromIndex).map((rule): RoutingTraceEntry => {\n        return { ruleId: rule.id, outcome: \"notEvaluated\", reason: null, failedConditions: [] };\n    });\n};\n"],"names":["listNotEvaluatedTrace","rules","fromIndex","rule"],"mappings":"AAOO,MAAMA,wBAAwB,CACjCC,OACAC,YAEOD,MAAM,KAAK,CAACC,WAAW,GAAG,CAAC,CAACC,OACxB;YAAE,QAAQA,KAAK,EAAE;YAAE,SAAS;YAAgB,QAAQ;YAAM,kBAAkB,EAAE;QAAC"}

package/domain/routing/listRoutingCandidates.d.ts

@@ -0,0 +1,15 @@
+import type { WorkflowExclusion } from "../../domain/settings/types.js";
+import type { RoutingDirectoryUser, RoutingUser } from "./types.js";
+export interface RoutingCandidatesInput {
+    members: RoutingDirectoryUser[];
+    candidateTeamIds: string[];
+    requesterId: string;
+    /** Active exclusions only (`filterActiveExclusions`). */
+    exclusions: WorkflowExclusion[];
+}
+/**
+ * The strategy candidates in their stable order (R111): members of the candidate teams, minus
+ * the requester and active exclusions, sorted by user id. Read access is checked later, lazily.
+ * Pure.
+ */
+export declare const listRoutingCandidates: (input: RoutingCandidatesInput) => RoutingUser[];

package/domain/routing/listRoutingCandidates.js

@@ -0,0 +1,7 @@
+const listRoutingCandidates = (input)=>input.members.filter((member)=>member.id !== input.requesterId && input.candidateTeamIds.some((teamId)=>member.teams?.includes(teamId)) && !input.exclusions.some((exclusion)=>exclusion.userId === member.id)).map((member)=>({
+            id: member.id,
+            displayName: member.displayName
+        })).sort((a, b)=>a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+export { listRoutingCandidates };
+
+//# sourceMappingURL=listRoutingCandidates.js.map

package/domain/routing/listRoutingCandidates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/listRoutingCandidates.js","sources":["../../../src/domain/routing/listRoutingCandidates.ts"],"sourcesContent":["import type { WorkflowExclusion } from \"~/domain/settings/types.js\";\nimport type { RoutingDirectoryUser, RoutingUser } from \"./types.js\";\n\nexport interface RoutingCandidatesInput {\n    members: RoutingDirectoryUser[];\n    candidateTeamIds: string[];\n    requesterId: string;\n    /** Active exclusions only (`filterActiveExclusions`). */\n    exclusions: WorkflowExclusion[];\n}\n\n/**\n * The strategy candidates in their stable order (R111): members of the candidate teams, minus\n * the requester and active exclusions, sorted by user id. Read access is checked later, lazily.\n * Pure.\n */\nexport const listRoutingCandidates = (input: RoutingCandidatesInput): RoutingUser[] => {\n    return input.members\n        .filter(member => {\n            return (\n                member.id !== input.requesterId &&\n                input.candidateTeamIds.some(teamId => member.teams?.includes(teamId)) &&\n                !input.exclusions.some(exclusion => exclusion.userId === member.id)\n            );\n        })\n        .map(member => ({ id: member.id, displayName: member.displayName }))\n        .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));\n};\n"],"names":["listRoutingCandidates","input","member","teamId","exclusion","a","b"],"mappings":"AAgBO,MAAMA,wBAAwB,CAACC,QAC3BA,MAAM,OAAO,CACf,MAAM,CAACC,CAAAA,SAEAA,OAAO,EAAE,KAAKD,MAAM,WAAW,IAC/BA,MAAM,gBAAgB,CAAC,IAAI,CAACE,CAAAA,SAAUD,OAAO,KAAK,EAAE,SAASC,YAC7D,CAACF,MAAM,UAAU,CAAC,IAAI,CAACG,CAAAA,YAAaA,UAAU,MAAM,KAAKF,OAAO,EAAE,GAGzE,GAAG,CAACA,CAAAA,SAAW;YAAE,IAAIA,OAAO,EAAE;YAAE,aAAaA,OAAO,WAAW;QAAC,IAChE,IAAI,CAAC,CAACG,GAAGC,IAAOD,EAAE,EAAE,GAAGC,EAAE,EAAE,GAAG,KAAKD,EAAE,EAAE,GAAGC,EAAE,EAAE,GAAG,IAAI"}

package/domain/routing/listStrategySkips.d.ts

@@ -0,0 +1,22 @@
+import type { RoutingSkipReason } from "./reasons.js";
+import type { RoutingCandidatesInput } from "./listRoutingCandidates.js";
+export interface StrategySkipsInput extends RoutingCandidatesInput {
+    /** The requester's pick, which the pick branch already records. */
+    pickedUserId: string | null;
+    /** The users a rule already skipped, which the rule branch records. */
+    ruleSkippedUserIds: string[];
+}
+export interface StrategySkip {
+    userId: string;
+    displayName: string;
+    /** The fixed reason for the record (D89, D97). */
+    reason: RoutingSkipReason;
+    /** The reason the inspector shows: an exclusion's own text when it has one (R129). */
+    shownReason: string;
+}
+/**
+ * The members of the candidate teams that `listRoutingCandidates` drops: the requester and the
+ * actively excluded, sorted by user id. The requester wins when both apply, and the picked user
+ * is left out because the pick branch records them, as are the users a rule already skipped. Pure.
+ */
+export declare const listStrategySkips: (input: StrategySkipsInput) => StrategySkip[];

package/domain/routing/listStrategySkips.js

@@ -0,0 +1,28 @@
+import { ROUTING_SKIP_REASONS } from "./reasons.js";
+const listStrategySkips = (input)=>{
+    const skips = [];
+    for (const member of input.members){
+        if (!input.candidateTeamIds.some((id)=>member.teams?.includes(id))) continue;
+        if (member.id === input.pickedUserId || input.ruleSkippedUserIds.includes(member.id)) continue;
+        if (member.id === input.requesterId) {
+            skips.push({
+                userId: member.id,
+                displayName: member.displayName,
+                reason: ROUTING_SKIP_REASONS.requester,
+                shownReason: ROUTING_SKIP_REASONS.requester
+            });
+            continue;
+        }
+        const exclusion = input.exclusions.find((item)=>item.userId === member.id);
+        if (exclusion) skips.push({
+            userId: member.id,
+            displayName: member.displayName,
+            reason: ROUTING_SKIP_REASONS.excluded,
+            shownReason: exclusion.reason || ROUTING_SKIP_REASONS.excluded
+        });
+    }
+    return skips.sort((a, b)=>a.userId < b.userId ? -1 : a.userId > b.userId ? 1 : 0);
+};
+export { listStrategySkips };
+
+//# sourceMappingURL=listStrategySkips.js.map

package/domain/routing/listStrategySkips.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/listStrategySkips.js","sources":["../../../src/domain/routing/listStrategySkips.ts"],"sourcesContent":["import { ROUTING_SKIP_REASONS } from \"./reasons.js\";\nimport type { RoutingSkipReason } from \"./reasons.js\";\nimport type { RoutingCandidatesInput } from \"./listRoutingCandidates.js\";\n\nexport interface StrategySkipsInput extends RoutingCandidatesInput {\n    /** The requester's pick, which the pick branch already records. */\n    pickedUserId: string | null;\n    /** The users a rule already skipped, which the rule branch records. */\n    ruleSkippedUserIds: string[];\n}\n\nexport interface StrategySkip {\n    userId: string;\n    displayName: string;\n    /** The fixed reason for the record (D89, D97). */\n    reason: RoutingSkipReason;\n    /** The reason the inspector shows: an exclusion's own text when it has one (R129). */\n    shownReason: string;\n}\n\n/**\n * The members of the candidate teams that `listRoutingCandidates` drops: the requester and the\n * actively excluded, sorted by user id. The requester wins when both apply, and the picked user\n * is left out because the pick branch records them, as are the users a rule already skipped. Pure.\n */\nexport const listStrategySkips = (input: StrategySkipsInput): StrategySkip[] => {\n    const skips: StrategySkip[] = [];\n    for (const member of input.members) {\n        if (!input.candidateTeamIds.some(id => member.teams?.includes(id))) {\n            continue;\n        }\n        if (member.id === input.pickedUserId || input.ruleSkippedUserIds.includes(member.id)) {\n            continue;\n        }\n        if (member.id === input.requesterId) {\n            skips.push({\n                userId: member.id,\n                displayName: member.displayName,\n                reason: ROUTING_SKIP_REASONS.requester,\n                shownReason: ROUTING_SKIP_REASONS.requester\n            });\n            continue;\n        }\n        const exclusion = input.exclusions.find(item => item.userId === member.id);\n        if (exclusion) {\n            skips.push({\n                userId: member.id,\n                displayName: member.displayName,\n                reason: ROUTING_SKIP_REASONS.excluded,\n                shownReason: exclusion.reason || ROUTING_SKIP_REASONS.excluded\n            });\n        }\n    }\n    return skips.sort((a, b) => (a.userId < b.userId ? -1 : a.userId > b.userId ? 1 : 0));\n};\n"],"names":["listStrategySkips","input","skips","member","id","ROUTING_SKIP_REASONS","exclusion","item","a","b"],"mappings":";AAyBO,MAAMA,oBAAoB,CAACC;IAC9B,MAAMC,QAAwB,EAAE;IAChC,KAAK,MAAMC,UAAUF,MAAM,OAAO,CAAE;QAChC,IAAI,CAACA,MAAM,gBAAgB,CAAC,IAAI,CAACG,CAAAA,KAAMD,OAAO,KAAK,EAAE,SAASC,MAC1D;QAEJ,IAAID,OAAO,EAAE,KAAKF,MAAM,YAAY,IAAIA,MAAM,kBAAkB,CAAC,QAAQ,CAACE,OAAO,EAAE,GAC/E;QAEJ,IAAIA,OAAO,EAAE,KAAKF,MAAM,WAAW,EAAE;YACjCC,MAAM,IAAI,CAAC;gBACP,QAAQC,OAAO,EAAE;gBACjB,aAAaA,OAAO,WAAW;gBAC/B,QAAQE,qBAAqB,SAAS;gBACtC,aAAaA,qBAAqB,SAAS;YAC/C;YACA;QACJ;QACA,MAAMC,YAAYL,MAAM,UAAU,CAAC,IAAI,CAACM,CAAAA,OAAQA,KAAK,MAAM,KAAKJ,OAAO,EAAE;QACzE,IAAIG,WACAJ,MAAM,IAAI,CAAC;YACP,QAAQC,OAAO,EAAE;YACjB,aAAaA,OAAO,WAAW;YAC/B,QAAQE,qBAAqB,QAAQ;YACrC,aAAaC,UAAU,MAAM,IAAID,qBAAqB,QAAQ;QAClE;IAER;IACA,OAAOH,MAAM,IAAI,CAAC,CAACM,GAAGC,IAAOD,EAAE,MAAM,GAAGC,EAAE,MAAM,GAAG,KAAKD,EAAE,MAAM,GAAGC,EAAE,MAAM,GAAG,IAAI;AACtF"}

package/domain/routing/matchRoutingRuleConditions.d.ts

@@ -0,0 +1,9 @@
+import type { RoutingRuleConditions } from "../../domain/workflow/types.js";
+import type { RoutingRuleFacts } from "./types.js";
+/**
+ * Whether every condition of a rule holds (spec 6, R113). Pure. A rule without conditions
+ * matches. The checks that need no lookup run first (`matchRoutingRuleLocalConditions`). Each
+ * condition is decided by its own predicate, which the rule inspector shares
+ * (`getFailedRoutingConditions`), so both always agree.
+ */
+export declare const matchRoutingRuleConditions: (conditions: RoutingRuleConditions, facts: RoutingRuleFacts) => boolean;

package/domain/routing/matchRoutingRuleConditions.js

@@ -0,0 +1,7 @@
+import { matchRoutingRuleLocalConditions } from "./matchRoutingRuleLocalConditions.js";
+import { matchesRequesterTeamCondition } from "./matchesRequesterTeamCondition.js";
+import { matchesFolderCondition } from "./matchesFolderCondition.js";
+const matchRoutingRuleConditions = (conditions, facts)=>matchRoutingRuleLocalConditions(conditions, facts) && matchesRequesterTeamCondition(conditions, facts) && matchesFolderCondition(conditions, facts);
+export { matchRoutingRuleConditions };
+
+//# sourceMappingURL=matchRoutingRuleConditions.js.map

package/domain/routing/matchRoutingRuleConditions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/matchRoutingRuleConditions.js","sources":["../../../src/domain/routing/matchRoutingRuleConditions.ts"],"sourcesContent":["import type { RoutingRuleConditions } from \"~/domain/workflow/types.js\";\nimport type { RoutingRuleFacts } from \"./types.js\";\nimport { matchRoutingRuleLocalConditions } from \"./matchRoutingRuleLocalConditions.js\";\nimport { matchesRequesterTeamCondition } from \"./matchesRequesterTeamCondition.js\";\nimport { matchesFolderCondition } from \"./matchesFolderCondition.js\";\n\n/**\n * Whether every condition of a rule holds (spec 6, R113). Pure. A rule without conditions\n * matches. The checks that need no lookup run first (`matchRoutingRuleLocalConditions`). Each\n * condition is decided by its own predicate, which the rule inspector shares\n * (`getFailedRoutingConditions`), so both always agree.\n */\nexport const matchRoutingRuleConditions = (\n    conditions: RoutingRuleConditions,\n    facts: RoutingRuleFacts\n): boolean => {\n    return (\n        matchRoutingRuleLocalConditions(conditions, facts) &&\n        matchesRequesterTeamCondition(conditions, facts) &&\n        matchesFolderCondition(conditions, facts)\n    );\n};\n"],"names":["matchRoutingRuleConditions","conditions","facts","matchRoutingRuleLocalConditions","matchesRequesterTeamCondition","matchesFolderCondition"],"mappings":";;;AAYO,MAAMA,6BAA6B,CACtCC,YACAC,QAGIC,gCAAgCF,YAAYC,UAC5CE,8BAA8BH,YAAYC,UAC1CG,uBAAuBJ,YAAYC"}

package/domain/routing/matchRoutingRuleLocalConditions.d.ts

@@ -0,0 +1,8 @@
+import type { RoutingRuleConditions } from "../../domain/workflow/types.js";
+import type { RoutingRuleLocalFacts } from "./types.js";
+/**
+ * Whether the conditions that need no lookup hold (spec 6, R113): the requester, the model and
+ * the folder type (a folder condition needs a target folder of the same type). Pure. Checked
+ * first, so a rule that fails here never reads the requester's teams or the folder chain.
+ */
+export declare const matchRoutingRuleLocalConditions: (conditions: RoutingRuleConditions, facts: RoutingRuleLocalFacts) => boolean;

package/domain/routing/matchRoutingRuleLocalConditions.js

@@ -0,0 +1,10 @@
+import { matchesRequesterUserCondition } from "./matchesRequesterUserCondition.js";
+import { matchesFolderTypeCondition } from "./matchesFolderTypeCondition.js";
+const matchRoutingRuleLocalConditions = (conditions, facts)=>{
+    if (!matchesRequesterUserCondition(conditions, facts)) return false;
+    if (conditions.modelId && conditions.modelId !== facts.modelId) return false;
+    return matchesFolderTypeCondition(conditions, facts);
+};
+export { matchRoutingRuleLocalConditions };
+
+//# sourceMappingURL=matchRoutingRuleLocalConditions.js.map

package/domain/routing/matchRoutingRuleLocalConditions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/matchRoutingRuleLocalConditions.js","sources":["../../../src/domain/routing/matchRoutingRuleLocalConditions.ts"],"sourcesContent":["import type { RoutingRuleConditions } from \"~/domain/workflow/types.js\";\nimport type { RoutingRuleLocalFacts } from \"./types.js\";\nimport { matchesRequesterUserCondition } from \"./matchesRequesterUserCondition.js\";\nimport { matchesFolderTypeCondition } from \"./matchesFolderTypeCondition.js\";\n\n/**\n * Whether the conditions that need no lookup hold (spec 6, R113): the requester, the model and\n * the folder type (a folder condition needs a target folder of the same type). Pure. Checked\n * first, so a rule that fails here never reads the requester's teams or the folder chain.\n */\nexport const matchRoutingRuleLocalConditions = (\n    conditions: RoutingRuleConditions,\n    facts: RoutingRuleLocalFacts\n): boolean => {\n    if (!matchesRequesterUserCondition(conditions, facts)) {\n        return false;\n    }\n    if (conditions.modelId && conditions.modelId !== facts.modelId) {\n        return false;\n    }\n    return matchesFolderTypeCondition(conditions, facts);\n};\n"],"names":["matchRoutingRuleLocalConditions","conditions","facts","matchesRequesterUserCondition","matchesFolderTypeCondition"],"mappings":";;AAUO,MAAMA,kCAAkC,CAC3CC,YACAC;IAEA,IAAI,CAACC,8BAA8BF,YAAYC,QAC3C,OAAO;IAEX,IAAID,WAAW,OAAO,IAAIA,WAAW,OAAO,KAAKC,MAAM,OAAO,EAC1D,OAAO;IAEX,OAAOE,2BAA2BH,YAAYC;AAClD"}

package/domain/routing/matchesFolderCondition.d.ts

@@ -0,0 +1,8 @@
+import type { RoutingRuleConditions } from "../../domain/workflow/types.js";
+import type { RoutingRuleFacts } from "./types.js";
+/**
+ * Whether a rule's folder condition holds. The target folder must be of the rule folder's type
+ * (`matchesFolderTypeCondition`); then the rule folder must be the target folder or, with
+ * `includeDescendants`, one of its ancestors. A rule without one matches. Pure.
+ */
+export declare const matchesFolderCondition: (conditions: RoutingRuleConditions, facts: RoutingRuleFacts) => boolean;

package/domain/routing/matchesFolderCondition.js

@@ -0,0 +1,11 @@
+import { matchesFolderTypeCondition } from "./matchesFolderTypeCondition.js";
+const matchesFolderCondition = (conditions, facts)=>{
+    const folder = conditions.folder;
+    if (!folder) return true;
+    if (!matchesFolderTypeCondition(conditions, facts) || !facts.folder) return false;
+    if (folder.id === facts.folder.id) return true;
+    return !!folder.includeDescendants && facts.folderChainIds.includes(folder.id);
+};
+export { matchesFolderCondition };
+
+//# sourceMappingURL=matchesFolderCondition.js.map

package/domain/routing/matchesFolderCondition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/matchesFolderCondition.js","sources":["../../../src/domain/routing/matchesFolderCondition.ts"],"sourcesContent":["import type { RoutingRuleConditions } from \"~/domain/workflow/types.js\";\nimport type { RoutingRuleFacts } from \"./types.js\";\nimport { matchesFolderTypeCondition } from \"./matchesFolderTypeCondition.js\";\n\n/**\n * Whether a rule's folder condition holds. The target folder must be of the rule folder's type\n * (`matchesFolderTypeCondition`); then the rule folder must be the target folder or, with\n * `includeDescendants`, one of its ancestors. A rule without one matches. Pure.\n */\nexport const matchesFolderCondition = (\n    conditions: RoutingRuleConditions,\n    facts: RoutingRuleFacts\n): boolean => {\n    const folder = conditions.folder;\n    if (!folder) {\n        return true;\n    }\n    if (!matchesFolderTypeCondition(conditions, facts) || !facts.folder) {\n        return false;\n    }\n    if (folder.id === facts.folder.id) {\n        return true;\n    }\n    return !!folder.includeDescendants && facts.folderChainIds.includes(folder.id);\n};\n"],"names":["matchesFolderCondition","conditions","facts","folder","matchesFolderTypeCondition"],"mappings":";AASO,MAAMA,yBAAyB,CAClCC,YACAC;IAEA,MAAMC,SAASF,WAAW,MAAM;IAChC,IAAI,CAACE,QACD,OAAO;IAEX,IAAI,CAACC,2BAA2BH,YAAYC,UAAU,CAACA,MAAM,MAAM,EAC/D,OAAO;IAEX,IAAIC,OAAO,EAAE,KAAKD,MAAM,MAAM,CAAC,EAAE,EAC7B,OAAO;IAEX,OAAO,CAAC,CAACC,OAAO,kBAAkB,IAAID,MAAM,cAAc,CAAC,QAAQ,CAACC,OAAO,EAAE;AACjF"}

package/domain/routing/matchesFolderTypeCondition.d.ts

@@ -0,0 +1,8 @@
+import type { RoutingRuleConditions } from "../../domain/workflow/types.js";
+import type { RoutingRuleLocalFacts } from "./types.js";
+/**
+ * Whether the target can match a rule's folder condition at all: it needs a target folder of the
+ * same type, so a target in the root matches no folder condition. A rule without one matches.
+ * Pure; needs no lookup.
+ */
+export declare const matchesFolderTypeCondition: (conditions: RoutingRuleConditions, facts: RoutingRuleLocalFacts) => boolean;

package/domain/routing/matchesFolderTypeCondition.js

@@ -0,0 +1,7 @@
+const matchesFolderTypeCondition = (conditions, facts)=>{
+    if (!conditions.folder) return true;
+    return !!facts.folder && conditions.folder.type === facts.folder.type;
+};
+export { matchesFolderTypeCondition };
+
+//# sourceMappingURL=matchesFolderTypeCondition.js.map

package/domain/routing/matchesFolderTypeCondition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/matchesFolderTypeCondition.js","sources":["../../../src/domain/routing/matchesFolderTypeCondition.ts"],"sourcesContent":["import type { RoutingRuleConditions } from \"~/domain/workflow/types.js\";\nimport type { RoutingRuleLocalFacts } from \"./types.js\";\n\n/**\n * Whether the target can match a rule's folder condition at all: it needs a target folder of the\n * same type, so a target in the root matches no folder condition. A rule without one matches.\n * Pure; needs no lookup.\n */\nexport const matchesFolderTypeCondition = (\n    conditions: RoutingRuleConditions,\n    facts: RoutingRuleLocalFacts\n): boolean => {\n    if (!conditions.folder) {\n        return true;\n    }\n    return !!facts.folder && conditions.folder.type === facts.folder.type;\n};\n"],"names":["matchesFolderTypeCondition","conditions","facts"],"mappings":"AAQO,MAAMA,6BAA6B,CACtCC,YACAC;IAEA,IAAI,CAACD,WAAW,MAAM,EAClB,OAAO;IAEX,OAAO,CAAC,CAACC,MAAM,MAAM,IAAID,WAAW,MAAM,CAAC,IAAI,KAAKC,MAAM,MAAM,CAAC,IAAI;AACzE"}

package/domain/routing/matchesRequesterTeamCondition.d.ts

@@ -0,0 +1,4 @@
+import type { RoutingRuleConditions } from "../../domain/workflow/types.js";
+import type { RoutingRuleFacts } from "./types.js";
+/** Whether a rule's requester team condition holds. A rule without one matches. Pure. */
+export declare const matchesRequesterTeamCondition: (conditions: RoutingRuleConditions, facts: RoutingRuleFacts) => boolean;

package/domain/routing/matchesRequesterTeamCondition.js

@@ -0,0 +1,4 @@
+const matchesRequesterTeamCondition = (conditions, facts)=>!conditions.requesterTeamId || facts.requesterTeamIds.includes(conditions.requesterTeamId);
+export { matchesRequesterTeamCondition };
+
+//# sourceMappingURL=matchesRequesterTeamCondition.js.map

package/domain/routing/matchesRequesterTeamCondition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/matchesRequesterTeamCondition.js","sources":["../../../src/domain/routing/matchesRequesterTeamCondition.ts"],"sourcesContent":["import type { RoutingRuleConditions } from \"~/domain/workflow/types.js\";\nimport type { RoutingRuleFacts } from \"./types.js\";\n\n/** Whether a rule's requester team condition holds. A rule without one matches. Pure. */\nexport const matchesRequesterTeamCondition = (\n    conditions: RoutingRuleConditions,\n    facts: RoutingRuleFacts\n): boolean => {\n    return (\n        !conditions.requesterTeamId || facts.requesterTeamIds.includes(conditions.requesterTeamId)\n    );\n};\n"],"names":["matchesRequesterTeamCondition","conditions","facts"],"mappings":"AAIO,MAAMA,gCAAgC,CACzCC,YACAC,QAGI,CAACD,WAAW,eAAe,IAAIC,MAAM,gBAAgB,CAAC,QAAQ,CAACD,WAAW,eAAe"}

package/domain/routing/matchesRequesterUserCondition.d.ts

@@ -0,0 +1,4 @@
+import type { RoutingRuleConditions } from "../../domain/workflow/types.js";
+import type { RoutingRuleLocalFacts } from "./types.js";
+/** Whether a rule's requester condition holds. A rule without one matches. Pure. */
+export declare const matchesRequesterUserCondition: (conditions: RoutingRuleConditions, facts: RoutingRuleLocalFacts) => boolean;

package/domain/routing/matchesRequesterUserCondition.js

@@ -0,0 +1,4 @@
+const matchesRequesterUserCondition = (conditions, facts)=>!conditions.requesterUserId || conditions.requesterUserId === facts.requesterId;
+export { matchesRequesterUserCondition };
+
+//# sourceMappingURL=matchesRequesterUserCondition.js.map

package/domain/routing/matchesRequesterUserCondition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/matchesRequesterUserCondition.js","sources":["../../../src/domain/routing/matchesRequesterUserCondition.ts"],"sourcesContent":["import type { RoutingRuleConditions } from \"~/domain/workflow/types.js\";\nimport type { RoutingRuleLocalFacts } from \"./types.js\";\n\n/** Whether a rule's requester condition holds. A rule without one matches. Pure. */\nexport const matchesRequesterUserCondition = (\n    conditions: RoutingRuleConditions,\n    facts: RoutingRuleLocalFacts\n): boolean => {\n    return !conditions.requesterUserId || conditions.requesterUserId === facts.requesterId;\n};\n"],"names":["matchesRequesterUserCondition","conditions","facts"],"mappings":"AAIO,MAAMA,gCAAgC,CACzCC,YACAC,QAEO,CAACD,WAAW,eAAe,IAAIA,WAAW,eAAe,KAAKC,MAAM,WAAW"}

package/domain/routing/orderLeastLoaded.d.ts

@@ -0,0 +1,7 @@
+import type { RoutingUser } from "./types.js";
+/**
+ * Least loaded (R115, D137): fewest in-review reviews first; ties go to the least recently
+ * assigned (no entry = never assigned = least recent), then to user id order. `loads` and
+ * `lastAssignedOn` are keyed by user id; a missing load is 0. Pure.
+ */
+export declare const orderLeastLoaded: (candidates: RoutingUser[], loads: ReadonlyMap<string, number>, lastAssignedOn: ReadonlyMap<string, string>) => RoutingUser[];

package/domain/routing/orderLeastLoaded.js

@@ -0,0 +1,18 @@
+const orderLeastLoaded = (candidates, loads, lastAssignedOn)=>[
+        ...candidates
+    ].sort((a, b)=>{
+        const load = (loads.get(a.id) ?? 0) - (loads.get(b.id) ?? 0);
+        if (0 !== load) return load;
+        const aOn = lastAssignedOn.get(a.id);
+        const bOn = lastAssignedOn.get(b.id);
+        if (aOn !== bOn) {
+            if (!aOn) return -1;
+            if (!bOn) return 1;
+            const time = Date.parse(aOn) - Date.parse(bOn);
+            if (0 !== time) return time;
+        }
+        return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+    });
+export { orderLeastLoaded };
+
+//# sourceMappingURL=orderLeastLoaded.js.map

package/domain/routing/orderLeastLoaded.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/orderLeastLoaded.js","sources":["../../../src/domain/routing/orderLeastLoaded.ts"],"sourcesContent":["import type { RoutingUser } from \"./types.js\";\n\n/**\n * Least loaded (R115, D137): fewest in-review reviews first; ties go to the least recently\n * assigned (no entry = never assigned = least recent), then to user id order. `loads` and\n * `lastAssignedOn` are keyed by user id; a missing load is 0. Pure.\n */\nexport const orderLeastLoaded = (\n    candidates: RoutingUser[],\n    loads: ReadonlyMap<string, number>,\n    lastAssignedOn: ReadonlyMap<string, string>\n): RoutingUser[] => {\n    return [...candidates].sort((a, b) => {\n        const load = (loads.get(a.id) ?? 0) - (loads.get(b.id) ?? 0);\n        if (load !== 0) {\n            return load;\n        }\n        const aOn = lastAssignedOn.get(a.id);\n        const bOn = lastAssignedOn.get(b.id);\n        if (aOn !== bOn) {\n            if (!aOn) {\n                return -1;\n            }\n            if (!bOn) {\n                return 1;\n            }\n            const time = Date.parse(aOn) - Date.parse(bOn);\n            if (time !== 0) {\n                return time;\n            }\n        }\n        return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;\n    });\n};\n"],"names":["orderLeastLoaded","candidates","loads","lastAssignedOn","a","b","load","aOn","bOn","time","Date"],"mappings":"AAOO,MAAMA,mBAAmB,CAC5BC,YACAC,OACAC,iBAEO;WAAIF;KAAW,CAAC,IAAI,CAAC,CAACG,GAAGC;QAC5B,MAAMC,OAAQJ,AAAAA,CAAAA,MAAM,GAAG,CAACE,EAAE,EAAE,KAAK,KAAMF,CAAAA,MAAM,GAAG,CAACG,EAAE,EAAE,KAAK;QAC1D,IAAIC,AAAS,MAATA,MACA,OAAOA;QAEX,MAAMC,MAAMJ,eAAe,GAAG,CAACC,EAAE,EAAE;QACnC,MAAMI,MAAML,eAAe,GAAG,CAACE,EAAE,EAAE;QACnC,IAAIE,QAAQC,KAAK;YACb,IAAI,CAACD,KACD,OAAO;YAEX,IAAI,CAACC,KACD,OAAO;YAEX,MAAMC,OAAOC,KAAK,KAAK,CAACH,OAAOG,KAAK,KAAK,CAACF;YAC1C,IAAIC,AAAS,MAATA,MACA,OAAOA;QAEf;QACA,OAAOL,EAAE,EAAE,GAAGC,EAAE,EAAE,GAAG,KAAKD,EAAE,EAAE,GAAGC,EAAE,EAAE,GAAG,IAAI;IAChD"}

package/domain/routing/orderRoundRobin.d.ts

@@ -0,0 +1,7 @@
+import type { RoutingUser } from "./types.js";
+/**
+ * Round robin (R115): the candidates (sorted by user id) starting with the first id after the
+ * last assignee, wrapping around. A last assignee who is no longer a candidate still marks the
+ * position; without one the order is unchanged. Pure.
+ */
+export declare const orderRoundRobin: (candidates: RoutingUser[], lastAssigneeId: string | null) => RoutingUser[];

package/domain/routing/orderRoundRobin.js

@@ -0,0 +1,16 @@
+const orderRoundRobin = (candidates, lastAssigneeId)=>{
+    if (!lastAssigneeId) return [
+        ...candidates
+    ];
+    const index = candidates.findIndex((candidate)=>candidate.id > lastAssigneeId);
+    if (-1 === index) return [
+        ...candidates
+    ];
+    return [
+        ...candidates.slice(index),
+        ...candidates.slice(0, index)
+    ];
+};
+export { orderRoundRobin };
+
+//# sourceMappingURL=orderRoundRobin.js.map

package/domain/routing/orderRoundRobin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/orderRoundRobin.js","sources":["../../../src/domain/routing/orderRoundRobin.ts"],"sourcesContent":["import type { RoutingUser } from \"./types.js\";\n\n/**\n * Round robin (R115): the candidates (sorted by user id) starting with the first id after the\n * last assignee, wrapping around. A last assignee who is no longer a candidate still marks the\n * position; without one the order is unchanged. Pure.\n */\nexport const orderRoundRobin = (\n    candidates: RoutingUser[],\n    lastAssigneeId: string | null\n): RoutingUser[] => {\n    if (!lastAssigneeId) {\n        return [...candidates];\n    }\n    const index = candidates.findIndex(candidate => candidate.id > lastAssigneeId);\n    if (index === -1) {\n        return [...candidates];\n    }\n    return [...candidates.slice(index), ...candidates.slice(0, index)];\n};\n"],"names":["orderRoundRobin","candidates","lastAssigneeId","index","candidate"],"mappings":"AAOO,MAAMA,kBAAkB,CAC3BC,YACAC;IAEA,IAAI,CAACA,gBACD,OAAO;WAAID;KAAW;IAE1B,MAAME,QAAQF,WAAW,SAAS,CAACG,CAAAA,YAAaA,UAAU,EAAE,GAAGF;IAC/D,IAAIC,AAAU,OAAVA,OACA,OAAO;WAAIF;KAAW;IAE1B,OAAO;WAAIA,WAAW,KAAK,CAACE;WAAWF,WAAW,KAAK,CAAC,GAAGE;KAAO;AACtE"}

package/domain/routing/reasons.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Fixed reasons on skip records and trace entries (R112). An exclusion's own text never goes
+ * into a record (D89, D97); only the inspector's trace and skipped list show it (R129).
+ */
+export declare const ROUTING_SKIP_REASONS: {
+    readonly requester: "The requester cannot review.";
+    readonly notMember: "Not a member of the step's teams.";
+    readonly excluded: "Excluded from reviews.";
+    readonly cannotRead: "Cannot read this content.";
+};
+export type RoutingSkipReason = (typeof ROUTING_SKIP_REASONS)[keyof typeof ROUTING_SKIP_REASONS];
+/**
+ * The fixed reason for a rule whose team target is not one of the step's teams (spec 6): the rule
+ * is skipped with a skip record without a user, and evaluation continues. Save-time validation and
+ * the inspector refuse such a rule, so it appears only for a stored workflow whose teams changed or
+ * that was written without validation.
+ */
+export declare const ROUTING_TEAM_TARGET_SKIP_REASON = "Not one of the step's teams.";
+/** The pool reason when anything in resolution failed (R116). */
+export declare const ROUTING_FAILED_REASON = "Routing failed; the step went to the pool.";
+/** The pool reason when a strategy found nobody who can review (R111). */
+export declare const ROUTING_NO_CANDIDATE_REASON = "No eligible candidate; the step went to the pool.";

package/domain/routing/reasons.js

@@ -0,0 +1,12 @@
+const ROUTING_SKIP_REASONS = {
+    requester: "The requester cannot review.",
+    notMember: "Not a member of the step's teams.",
+    excluded: "Excluded from reviews.",
+    cannotRead: "Cannot read this content."
+};
+const ROUTING_TEAM_TARGET_SKIP_REASON = "Not one of the step's teams.";
+const ROUTING_FAILED_REASON = "Routing failed; the step went to the pool.";
+const ROUTING_NO_CANDIDATE_REASON = "No eligible candidate; the step went to the pool.";
+export { ROUTING_FAILED_REASON, ROUTING_NO_CANDIDATE_REASON, ROUTING_SKIP_REASONS, ROUTING_TEAM_TARGET_SKIP_REASON };
+
+//# sourceMappingURL=reasons.js.map

package/domain/routing/reasons.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/reasons.js","sources":["../../../src/domain/routing/reasons.ts"],"sourcesContent":["/**\n * Fixed reasons on skip records and trace entries (R112). An exclusion's own text never goes\n * into a record (D89, D97); only the inspector's trace and skipped list show it (R129).\n */\nexport const ROUTING_SKIP_REASONS = {\n    requester: \"The requester cannot review.\",\n    notMember: \"Not a member of the step's teams.\",\n    excluded: \"Excluded from reviews.\",\n    cannotRead: \"Cannot read this content.\"\n} as const;\n\nexport type RoutingSkipReason = (typeof ROUTING_SKIP_REASONS)[keyof typeof ROUTING_SKIP_REASONS];\n\n/**\n * The fixed reason for a rule whose team target is not one of the step's teams (spec 6): the rule\n * is skipped with a skip record without a user, and evaluation continues. Save-time validation and\n * the inspector refuse such a rule, so it appears only for a stored workflow whose teams changed or\n * that was written without validation.\n */\nexport const ROUTING_TEAM_TARGET_SKIP_REASON = \"Not one of the step's teams.\";\n\n/** The pool reason when anything in resolution failed (R116). */\nexport const ROUTING_FAILED_REASON = \"Routing failed; the step went to the pool.\";\n\n/** The pool reason when a strategy found nobody who can review (R111). */\nexport const ROUTING_NO_CANDIDATE_REASON = \"No eligible candidate; the step went to the pool.\";\n"],"names":["ROUTING_SKIP_REASONS","ROUTING_TEAM_TARGET_SKIP_REASON","ROUTING_FAILED_REASON","ROUTING_NO_CANDIDATE_REASON"],"mappings":"AAIO,MAAMA,uBAAuB;IAChC,WAAW;IACX,WAAW;IACX,UAAU;IACV,YAAY;AAChB;AAUO,MAAMC,kCAAkC;AAGxC,MAAMC,wBAAwB;AAG9B,MAAMC,8BAA8B"}

package/domain/routing/redactStepCandidates.d.ts

@@ -0,0 +1,8 @@
+import type { WorkflowsPermissionSet } from "../../domain/permissions/types.js";
+import type { StepCandidate } from "./types.js";
+/**
+ * The step candidates one viewer may see (D89, D97, R120). Pure. `editor` and `reassign` (full
+ * access sets both) see why a person is excluded; everyone else sees only that they are, because an
+ * exclusion's reason is personal. Order is kept.
+ */
+export declare const redactStepCandidates: (candidates: StepCandidate[], permissions: WorkflowsPermissionSet) => StepCandidate[];

package/domain/routing/redactStepCandidates.js

@@ -0,0 +1,12 @@
+const redactStepCandidates = (candidates, permissions)=>{
+    if (permissions.editor || permissions.reassign) return candidates.map((candidate)=>({
+            ...candidate
+        }));
+    return candidates.map((candidate)=>({
+            ...candidate,
+            excludedReason: null
+        }));
+};
+export { redactStepCandidates };
+
+//# sourceMappingURL=redactStepCandidates.js.map

package/domain/routing/redactStepCandidates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/redactStepCandidates.js","sources":["../../../src/domain/routing/redactStepCandidates.ts"],"sourcesContent":["import type { WorkflowsPermissionSet } from \"~/domain/permissions/types.js\";\nimport type { StepCandidate } from \"./types.js\";\n\n/**\n * The step candidates one viewer may see (D89, D97, R120). Pure. `editor` and `reassign` (full\n * access sets both) see why a person is excluded; everyone else sees only that they are, because an\n * exclusion's reason is personal. Order is kept.\n */\nexport const redactStepCandidates = (\n    candidates: StepCandidate[],\n    permissions: WorkflowsPermissionSet\n): StepCandidate[] => {\n    if (permissions.editor || permissions.reassign) {\n        return candidates.map(candidate => ({ ...candidate }));\n    }\n    return candidates.map(candidate => ({ ...candidate, excludedReason: null }));\n};\n"],"names":["redactStepCandidates","candidates","permissions","candidate"],"mappings":"AAQO,MAAMA,uBAAuB,CAChCC,YACAC;IAEA,IAAIA,YAAY,MAAM,IAAIA,YAAY,QAAQ,EAC1C,OAAOD,WAAW,GAAG,CAACE,CAAAA,YAAc;YAAE,GAAGA,SAAS;QAAC;IAEvD,OAAOF,WAAW,GAAG,CAACE,CAAAA,YAAc;YAAE,GAAGA,SAAS;YAAE,gBAAgB;QAAK;AAC7E"}

package/domain/routing/toInspectionTrace.d.ts

@@ -0,0 +1,6 @@
+import type { RoutingInspectionTraceEntry } from "../../domain/routing/types.js";
+import type { RoutingTraceEntry } from "../../domain/routing/types.js";
+/**
+ * Every entry carries its failed conditions, empty unless a rule did not match (R289). Pure.
+ */
+export declare const toInspectionTrace: (trace: RoutingTraceEntry[]) => RoutingInspectionTraceEntry[];

package/domain/routing/toInspectionTrace.js

@@ -0,0 +1,11 @@
+const toInspectionTrace = (trace)=>trace.map((entry)=>({
+            ruleId: entry.ruleId,
+            outcome: entry.outcome,
+            reason: entry.reason,
+            failedConditions: [
+                ...entry.failedConditions ?? []
+            ]
+        }));
+export { toInspectionTrace };
+
+//# sourceMappingURL=toInspectionTrace.js.map

package/domain/routing/toInspectionTrace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/routing/toInspectionTrace.js","sources":["../../../src/domain/routing/toInspectionTrace.ts"],"sourcesContent":["import type { RoutingInspectionTraceEntry } from \"~/domain/routing/types.js\";\nimport type { RoutingTraceEntry } from \"~/domain/routing/types.js\";\n\n/**\n * Every entry carries its failed conditions, empty unless a rule did not match (R289). Pure.\n */\nexport const toInspectionTrace = (trace: RoutingTraceEntry[]): RoutingInspectionTraceEntry[] => {\n    return trace.map(entry => {\n        return {\n            ruleId: entry.ruleId,\n            outcome: entry.outcome,\n            reason: entry.reason,\n            failedConditions: [...(entry.failedConditions ?? [])]\n        };\n    });\n};\n"],"names":["toInspectionTrace","trace","entry"],"mappings":"AAMO,MAAMA,oBAAoB,CAACC,QACvBA,MAAM,GAAG,CAACC,CAAAA,QACN;YACH,QAAQA,MAAM,MAAM;YACpB,SAASA,MAAM,OAAO;YACtB,QAAQA,MAAM,MAAM;YACpB,kBAAkB;mBAAKA,MAAM,gBAAgB,IAAI,EAAE;aAAE;QACzD"}

package/domain/routing/toRoutingEvaluation.d.ts

@@ -0,0 +1,20 @@
+import type { AssignmentDecision } from "../../domain/assignment/types.js";
+import type { RoutingStrategy } from "../../domain/workflow/types.js";
+import type { RoutingEvaluation, RoutingSkippedUser, RoutingSource, RoutingTraceEntry, RoutingUser } from "./types.js";
+export interface RoutingDecisionInput {
+    owner: RoutingUser | null;
+    source: RoutingSource;
+    ruleId: string | null;
+    strategy: RoutingStrategy;
+    candidateTeamIds: string[];
+    reason: string | null;
+    /** The skips so far, in decision order. */
+    skips: AssignmentDecision[];
+    trace: RoutingTraceEntry[];
+    /** The skipped people so far, in decision order (R129). */
+    skipped: RoutingSkippedUser[];
+    /** The strategy's candidate order; given only in inspector mode when a strategy ran (R289). */
+    strategyOrder?: RoutingUser[];
+}
+/** The evaluation with its outcome record appended after the skips (R117). Pure. */
+export declare const toRoutingEvaluation: (input: RoutingDecisionInput) => RoutingEvaluation;