@exellix/ai-tasks 7.8.0

package/dist/task-strategies/canonicalInputExecutionStrategies.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Task **input** strategies: optional authoring / template hints for consoles and Xynthesis.
+ * They do **not** select Narrix invocation (use `narrixMode` on the request) and do **not** decide
+ * what material is attached to PRE by default (PRE receives the full available bundle; see runtime D6).
+ * Keys match Catalox catalog {@link AI_TASK_INPUT_STRATEGIES_CATALOG_ID}.
+ */
+export declare const CANONICAL_INPUT_STRATEGIES: readonly [{
+    readonly strategyKey: "no-narrative";
+    readonly title: "No narrative";
+    readonly description: "Default authoring hint: task is not framed as requiring a Narrix-first narrative. Narrix still runs when `narrixMode` is not `off`.";
+    readonly domain: "input";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["task-input"];
+}, {
+    readonly strategyKey: "narrative-only";
+    readonly title: "Narrative only";
+    readonly description: "UX / template hint: prefer framing around Narrix-derived material inside Xynthesis when templates allow.";
+    readonly domain: "input";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["task-input"];
+}, {
+    readonly strategyKey: "narrative-with-context";
+    readonly title: "Narrative with context";
+    readonly description: "UX / template hint: combine narrative with broader memory/web framing inside Xynthesis when templates allow.";
+    readonly domain: "input";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["task-input"];
+}];
+/**
+ * Task **execution** strategies: catalog metadata for MAIN wrappers (`RunTaskRequest.executionStrategies`).
+ * Runtime wrappers: `planner` (FuncX before MAIN), `optimizer` (FuncX after each MAIN attempt). `direct` describes plain MAIN when `executionStrategies` is `[]`.
+ * Keys match Catalox catalogs {@link AI_TASK_EXECUTION_STRATEGIES_CATALOG_ID} and {@link AI_TASK_MAIN_EXECUTION_WRAPPERS_CATALOG_ID} (same seeded rows).
+ */
+export declare const CANONICAL_EXECUTION_STRATEGIES: readonly [{
+    readonly strategyKey: "direct";
+    readonly title: "Direct";
+    readonly description: "Plain MAIN: no planner/optimizer entries — `executionStrategies: []`. Skill runs once via `runSkill`.";
+    readonly domain: "execution";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["main-execution"];
+    readonly runtimeKind: "direct";
+    readonly requestShape: "empty-execution-strategies";
+    readonly phase: "main";
+    readonly selectableInExecutionStrategies: false;
+    readonly safeRuntimeFields: [];
+    readonly example: {
+        readonly executionStrategies: readonly [];
+    };
+    readonly notes: ["`direct` is represented by an empty `executionStrategies` array; it is not valid as an `executionStrategies[]` row."];
+}, {
+    readonly strategyKey: "planner";
+    readonly title: "Planner";
+    readonly description: "FuncX `execution/plan` runs once before MAIN (generic envelope); merges instructions/prompt/variables into the task request.";
+    readonly domain: "execution";
+    readonly multiSelectable: true;
+    readonly appliesTo: ["pre-main-execution"];
+    readonly runtimeKind: "funcx-wrapper";
+    readonly requestShape: "executionStrategies-row";
+    readonly phase: "before";
+    readonly selectableInExecutionStrategies: true;
+    readonly defaultFunctionId: "execution/plan";
+    readonly functionEnvelope: "execution-strategy-generic-v1";
+    readonly safeRuntimeFields: ["defaultFunctionId"];
+    readonly example: {
+        readonly executionStrategies: readonly [{
+            readonly strategyKey: "planner";
+            readonly phase: "before";
+            readonly priority: 10;
+        }];
+    };
+    readonly notes: ["Planner rows must use phase `before`.", "Per-invocation `args.functionId` overrides catalog/default function id."];
+}, {
+    readonly strategyKey: "optimizer";
+    readonly title: "Optimizer";
+    readonly description: "FuncX `execution/evaluate-result` after each MAIN attempt; may retry MAIN with feedback until satisfied or max iterations.";
+    readonly domain: "execution";
+    readonly multiSelectable: true;
+    readonly appliesTo: ["post-main-execution"];
+    readonly runtimeKind: "funcx-wrapper";
+    readonly requestShape: "executionStrategies-row";
+    readonly phase: "after";
+    readonly selectableInExecutionStrategies: true;
+    readonly defaultFunctionId: "execution/evaluate-result";
+    readonly functionEnvelope: "execution-strategy-generic-v1";
+    readonly retryBehavior: "Runs MAIN until satisfied or maxIterations is reached. Omitted maxIterations uses AI_TASKS_OPTIMIZER_MAX_ITERATIONS or 3.";
+    readonly safeRuntimeFields: ["defaultFunctionId"];
+    readonly example: {
+        readonly executionStrategies: readonly [{
+            readonly strategyKey: "optimizer";
+            readonly phase: "after";
+            readonly priority: 20;
+            readonly maxIterations: 3;
+        }];
+    };
+    readonly notes: ["Optimizer rows must use phase `after`.", "Only the first optimizer after priority sorting drives the retry loop.", "Per-invocation `args.functionId` overrides catalog/default function id."];
+}];
+/**
+ * Canonical rows for {@link AI_TASK_MAIN_EXECUTION_WRAPPERS_CATALOG_ID}; identical to {@link CANONICAL_EXECUTION_STRATEGIES}.
+ */
+export declare const CANONICAL_MAIN_EXECUTION_WRAPPERS: readonly [{
+    readonly strategyKey: "direct";
+    readonly title: "Direct";
+    readonly description: "Plain MAIN: no planner/optimizer entries — `executionStrategies: []`. Skill runs once via `runSkill`.";
+    readonly domain: "execution";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["main-execution"];
+    readonly runtimeKind: "direct";
+    readonly requestShape: "empty-execution-strategies";
+    readonly phase: "main";
+    readonly selectableInExecutionStrategies: false;
+    readonly safeRuntimeFields: [];
+    readonly example: {
+        readonly executionStrategies: readonly [];
+    };
+    readonly notes: ["`direct` is represented by an empty `executionStrategies` array; it is not valid as an `executionStrategies[]` row."];
+}, {
+    readonly strategyKey: "planner";
+    readonly title: "Planner";
+    readonly description: "FuncX `execution/plan` runs once before MAIN (generic envelope); merges instructions/prompt/variables into the task request.";
+    readonly domain: "execution";
+    readonly multiSelectable: true;
+    readonly appliesTo: ["pre-main-execution"];
+    readonly runtimeKind: "funcx-wrapper";
+    readonly requestShape: "executionStrategies-row";
+    readonly phase: "before";
+    readonly selectableInExecutionStrategies: true;
+    readonly defaultFunctionId: "execution/plan";
+    readonly functionEnvelope: "execution-strategy-generic-v1";
+    readonly safeRuntimeFields: ["defaultFunctionId"];
+    readonly example: {
+        readonly executionStrategies: readonly [{
+            readonly strategyKey: "planner";
+            readonly phase: "before";
+            readonly priority: 10;
+        }];
+    };
+    readonly notes: ["Planner rows must use phase `before`.", "Per-invocation `args.functionId` overrides catalog/default function id."];
+}, {
+    readonly strategyKey: "optimizer";
+    readonly title: "Optimizer";
+    readonly description: "FuncX `execution/evaluate-result` after each MAIN attempt; may retry MAIN with feedback until satisfied or max iterations.";
+    readonly domain: "execution";
+    readonly multiSelectable: true;
+    readonly appliesTo: ["post-main-execution"];
+    readonly runtimeKind: "funcx-wrapper";
+    readonly requestShape: "executionStrategies-row";
+    readonly phase: "after";
+    readonly selectableInExecutionStrategies: true;
+    readonly defaultFunctionId: "execution/evaluate-result";
+    readonly functionEnvelope: "execution-strategy-generic-v1";
+    readonly retryBehavior: "Runs MAIN until satisfied or maxIterations is reached. Omitted maxIterations uses AI_TASKS_OPTIMIZER_MAX_ITERATIONS or 3.";
+    readonly safeRuntimeFields: ["defaultFunctionId"];
+    readonly example: {
+        readonly executionStrategies: readonly [{
+            readonly strategyKey: "optimizer";
+            readonly phase: "after";
+            readonly priority: 20;
+            readonly maxIterations: 3;
+        }];
+    };
+    readonly notes: ["Optimizer rows must use phase `after`.", "Only the first optimizer after priority sorting drives the retry loop.", "Per-invocation `args.functionId` overrides catalog/default function id."];
+}];
+export type InputStrategyKey = (typeof CANONICAL_INPUT_STRATEGIES)[number]["strategyKey"];
+export type ExecutionStrategyKey = (typeof CANONICAL_EXECUTION_STRATEGIES)[number]["strategyKey"];
+export declare const CANONICAL_INPUT_STRATEGY_KEYS: readonly InputStrategyKey[];
+export declare const CANONICAL_EXECUTION_STRATEGY_KEYS: readonly ExecutionStrategyKey[];
+export declare const TASK_INPUT_STRATEGIES_CATALOG_ID: "ai-task-input-strategies";
+export declare const TASK_EXECUTION_STRATEGIES_CATALOG_ID: "ai-task-execution-strategies";
+export declare const TASK_EXECUTION_STRATEGY_CATALOG_ID: "execution-strategy";
+export declare const INPUT_EXECUTION_STRATEGIES_APP_ID: "ai-tasks";
+//# sourceMappingURL=canonicalInputExecutionStrategies.d.ts.map

package/dist/task-strategies/canonicalInputExecutionStrategies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalInputExecutionStrategies.d.ts","sourceRoot":"","sources":["../../src/task-strategies/canonicalInputExecutionStrategies.ts"],"names":[],"mappings":"AAmBA;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;EA4BsB,CAAC;AAE9D;;;;GAIG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqEkB,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAiC,CAAC;AAEhF,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,CAAC;AAE1F,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,8BAA8B,CAAC,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,CAAC;AAElG,eAAO,MAAM,6BAA6B,EAAE,SAAS,gBAAgB,EACf,CAAC;AAEvD,eAAO,MAAM,iCAAiC,EAAE,SAAS,oBAAoB,EACnB,CAAC;AAE3D,eAAO,MAAM,gCAAgC,4BAAsC,CAAC;AACpF,eAAO,MAAM,oCAAoC,gCAA0C,CAAC;AAC5F,eAAO,MAAM,kCAAkC,sBAAwC,CAAC;AAExF,eAAO,MAAM,iCAAiC,YAAkB,CAAC"}

package/dist/task-strategies/canonicalInputExecutionStrategies.js

@@ -0,0 +1,117 @@
+import { AI_TASK_EXECUTION_STRATEGIES_CATALOG_ID, AI_TASK_EXECUTION_STRATEGY_CATALOG_ID, AI_TASK_INPUT_STRATEGIES_CATALOG_ID, AI_TASKS_APP_ID, TASK_STRATEGY_APPLIES_TO_MAIN_EXECUTION, TASK_STRATEGY_APPLIES_TO_POST_MAIN_EXECUTION, TASK_STRATEGY_APPLIES_TO_PRE_MAIN_EXECUTION, TASK_STRATEGY_APPLIES_TO_TASK_INPUT, } from "./constants.js";
+import { DEFAULT_OPTIMIZER_MAX_ITERATIONS, ENV_OPTIMIZER_MAX_ITERATIONS, FUNCX_EXECUTION_EVALUATE_RESULT_FUNCTION_ID, FUNCX_EXECUTION_PLAN_FUNCTION_ID, } from "../execution-strategies/constants.js";
+/**
+ * Task **input** strategies: optional authoring / template hints for consoles and Xynthesis.
+ * They do **not** select Narrix invocation (use `narrixMode` on the request) and do **not** decide
+ * what material is attached to PRE by default (PRE receives the full available bundle; see runtime D6).
+ * Keys match Catalox catalog {@link AI_TASK_INPUT_STRATEGIES_CATALOG_ID}.
+ */
+export const CANONICAL_INPUT_STRATEGIES = [
+    {
+        strategyKey: "no-narrative",
+        title: "No narrative",
+        description: "Default authoring hint: task is not framed as requiring a Narrix-first narrative. Narrix still runs when `narrixMode` is not `off`.",
+        domain: "input",
+        multiSelectable: false,
+        appliesTo: [TASK_STRATEGY_APPLIES_TO_TASK_INPUT],
+    },
+    {
+        strategyKey: "narrative-only",
+        title: "Narrative only",
+        description: "UX / template hint: prefer framing around Narrix-derived material inside Xynthesis when templates allow.",
+        domain: "input",
+        multiSelectable: false,
+        appliesTo: [TASK_STRATEGY_APPLIES_TO_TASK_INPUT],
+    },
+    {
+        strategyKey: "narrative-with-context",
+        title: "Narrative with context",
+        description: "UX / template hint: combine narrative with broader memory/web framing inside Xynthesis when templates allow.",
+        domain: "input",
+        multiSelectable: false,
+        appliesTo: [TASK_STRATEGY_APPLIES_TO_TASK_INPUT],
+    },
+];
+/**
+ * Task **execution** strategies: catalog metadata for MAIN wrappers (`RunTaskRequest.executionStrategies`).
+ * Runtime wrappers: `planner` (FuncX before MAIN), `optimizer` (FuncX after each MAIN attempt). `direct` describes plain MAIN when `executionStrategies` is `[]`.
+ * Keys match Catalox catalogs {@link AI_TASK_EXECUTION_STRATEGIES_CATALOG_ID} and {@link AI_TASK_MAIN_EXECUTION_WRAPPERS_CATALOG_ID} (same seeded rows).
+ */
+export const CANONICAL_EXECUTION_STRATEGIES = [
+    {
+        strategyKey: "direct",
+        title: "Direct",
+        description: "Plain MAIN: no planner/optimizer entries — `executionStrategies: []`. Skill runs once via `runSkill`.",
+        domain: "execution",
+        multiSelectable: false,
+        appliesTo: [TASK_STRATEGY_APPLIES_TO_MAIN_EXECUTION],
+        runtimeKind: "direct",
+        requestShape: "empty-execution-strategies",
+        phase: "main",
+        selectableInExecutionStrategies: false,
+        safeRuntimeFields: [],
+        example: {
+            executionStrategies: [],
+        },
+        notes: [
+            "`direct` is represented by an empty `executionStrategies` array; it is not valid as an `executionStrategies[]` row.",
+        ],
+    },
+    {
+        strategyKey: "planner",
+        title: "Planner",
+        description: "FuncX `execution/plan` runs once before MAIN (generic envelope); merges instructions/prompt/variables into the task request.",
+        domain: "execution",
+        multiSelectable: true,
+        appliesTo: [TASK_STRATEGY_APPLIES_TO_PRE_MAIN_EXECUTION],
+        runtimeKind: "funcx-wrapper",
+        requestShape: "executionStrategies-row",
+        phase: "before",
+        selectableInExecutionStrategies: true,
+        defaultFunctionId: FUNCX_EXECUTION_PLAN_FUNCTION_ID,
+        functionEnvelope: "execution-strategy-generic-v1",
+        safeRuntimeFields: ["defaultFunctionId"],
+        example: {
+            executionStrategies: [{ strategyKey: "planner", phase: "before", priority: 10 }],
+        },
+        notes: [
+            "Planner rows must use phase `before`.",
+            "Per-invocation `args.functionId` overrides catalog/default function id.",
+        ],
+    },
+    {
+        strategyKey: "optimizer",
+        title: "Optimizer",
+        description: "FuncX `execution/evaluate-result` after each MAIN attempt; may retry MAIN with feedback until satisfied or max iterations.",
+        domain: "execution",
+        multiSelectable: true,
+        appliesTo: [TASK_STRATEGY_APPLIES_TO_POST_MAIN_EXECUTION],
+        runtimeKind: "funcx-wrapper",
+        requestShape: "executionStrategies-row",
+        phase: "after",
+        selectableInExecutionStrategies: true,
+        defaultFunctionId: FUNCX_EXECUTION_EVALUATE_RESULT_FUNCTION_ID,
+        functionEnvelope: "execution-strategy-generic-v1",
+        retryBehavior: `Runs MAIN until satisfied or maxIterations is reached. Omitted maxIterations uses ${ENV_OPTIMIZER_MAX_ITERATIONS} or ${DEFAULT_OPTIMIZER_MAX_ITERATIONS}.`,
+        safeRuntimeFields: ["defaultFunctionId"],
+        example: {
+            executionStrategies: [{ strategyKey: "optimizer", phase: "after", priority: 20, maxIterations: 3 }],
+        },
+        notes: [
+            "Optimizer rows must use phase `after`.",
+            "Only the first optimizer after priority sorting drives the retry loop.",
+            "Per-invocation `args.functionId` overrides catalog/default function id.",
+        ],
+    },
+];
+/**
+ * Canonical rows for {@link AI_TASK_MAIN_EXECUTION_WRAPPERS_CATALOG_ID}; identical to {@link CANONICAL_EXECUTION_STRATEGIES}.
+ */
+export const CANONICAL_MAIN_EXECUTION_WRAPPERS = CANONICAL_EXECUTION_STRATEGIES;
+export const CANONICAL_INPUT_STRATEGY_KEYS = CANONICAL_INPUT_STRATEGIES.map((s) => s.strategyKey);
+export const CANONICAL_EXECUTION_STRATEGY_KEYS = CANONICAL_EXECUTION_STRATEGIES.map((s) => s.strategyKey);
+export const TASK_INPUT_STRATEGIES_CATALOG_ID = AI_TASK_INPUT_STRATEGIES_CATALOG_ID;
+export const TASK_EXECUTION_STRATEGIES_CATALOG_ID = AI_TASK_EXECUTION_STRATEGIES_CATALOG_ID;
+export const TASK_EXECUTION_STRATEGY_CATALOG_ID = AI_TASK_EXECUTION_STRATEGY_CATALOG_ID;
+export const INPUT_EXECUTION_STRATEGIES_APP_ID = AI_TASKS_APP_ID;
+//# sourceMappingURL=canonicalInputExecutionStrategies.js.map

package/dist/task-strategies/canonicalInputExecutionStrategies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalInputExecutionStrategies.js","sourceRoot":"","sources":["../../src/task-strategies/canonicalInputExecutionStrategies.ts"],"names":[],"mappings":"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"}

package/dist/task-strategies/canonicalNarrixModes.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Canonical **Narrix invocation modes** for `RunTaskRequest.narrixMode`.
+ * Keys match Catalox catalog {@link AI_TASK_NARRIX_MODES_CATALOG_ID}.
+ */
+export declare const CANONICAL_NARRIX_MODES: readonly [{
+    readonly strategyKey: "off";
+    readonly title: "Off";
+    readonly description: "Explicitly disables Narrix for this run (even if `narrix` / `narrixInput` are present). Omit `narrixMode` to allow inference from those fields instead.";
+    readonly domain: "narrix";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["narrix-mode"];
+}, {
+    readonly strategyKey: "preprocessor";
+    readonly title: "Preprocessor";
+    readonly description: "Run the record/dataset Narrix preprocessor (`request.narrix`) at the start of `runTask`, before local tasks and pipeline PRE.";
+    readonly domain: "narrix";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["narrix-mode"];
+}, {
+    readonly strategyKey: "handler";
+    readonly title: "Handler (structured)";
+    readonly description: "Run structured Narrix from `narrixInput` at the start of `runTask` (or omit mode when only `narrixInput` is set — inferred as handler), before local tasks and pipeline PRE.";
+    readonly domain: "narrix";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["narrix-mode"];
+}];
+export type NarrixModeKey = (typeof CANONICAL_NARRIX_MODES)[number]["strategyKey"];
+export declare const CANONICAL_NARRIX_MODE_KEYS: readonly NarrixModeKey[];
+export declare const NARRIX_MODES_CATALOG_ID: "ai-task-narrix-modes";
+export declare const NARRIX_MODES_STRATEGIES_APP_ID: "ai-tasks";
+//# sourceMappingURL=canonicalNarrixModes.d.ts.map

package/dist/task-strategies/canonicalNarrixModes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalNarrixModes.d.ts","sourceRoot":"","sources":["../../src/task-strategies/canonicalNarrixModes.ts"],"names":[],"mappings":"AAOA;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;EA4B0B,CAAC;AAE9D,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,CAAC;AAEnF,eAAO,MAAM,0BAA0B,EAAE,SAAS,aAAa,EAAqD,CAAC;AAErH,eAAO,MAAM,uBAAuB,wBAAkC,CAAC;AAEvE,eAAO,MAAM,8BAA8B,YAAkB,CAAC"}

package/dist/task-strategies/canonicalNarrixModes.js

@@ -0,0 +1,35 @@
+import { AI_TASK_NARRIX_MODES_CATALOG_ID, AI_TASKS_APP_ID, TASK_STRATEGY_APPLIES_TO_NARRIX_MODE, } from "./constants.js";
+/**
+ * Canonical **Narrix invocation modes** for `RunTaskRequest.narrixMode`.
+ * Keys match Catalox catalog {@link AI_TASK_NARRIX_MODES_CATALOG_ID}.
+ */
+export const CANONICAL_NARRIX_MODES = [
+    {
+        strategyKey: "off",
+        title: "Off",
+        description: "Explicitly disables Narrix for this run (even if `narrix` / `narrixInput` are present). Omit `narrixMode` to allow inference from those fields instead.",
+        domain: "narrix",
+        multiSelectable: false,
+        appliesTo: [TASK_STRATEGY_APPLIES_TO_NARRIX_MODE],
+    },
+    {
+        strategyKey: "preprocessor",
+        title: "Preprocessor",
+        description: "Run the record/dataset Narrix preprocessor (`request.narrix`) at the start of `runTask`, before local tasks and pipeline PRE.",
+        domain: "narrix",
+        multiSelectable: false,
+        appliesTo: [TASK_STRATEGY_APPLIES_TO_NARRIX_MODE],
+    },
+    {
+        strategyKey: "handler",
+        title: "Handler (structured)",
+        description: "Run structured Narrix from `narrixInput` at the start of `runTask` (or omit mode when only `narrixInput` is set — inferred as handler), before local tasks and pipeline PRE.",
+        domain: "narrix",
+        multiSelectable: false,
+        appliesTo: [TASK_STRATEGY_APPLIES_TO_NARRIX_MODE],
+    },
+];
+export const CANONICAL_NARRIX_MODE_KEYS = CANONICAL_NARRIX_MODES.map((m) => m.strategyKey);
+export const NARRIX_MODES_CATALOG_ID = AI_TASK_NARRIX_MODES_CATALOG_ID;
+export const NARRIX_MODES_STRATEGIES_APP_ID = AI_TASKS_APP_ID;
+//# sourceMappingURL=canonicalNarrixModes.js.map

package/dist/task-strategies/canonicalNarrixModes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalNarrixModes.js","sourceRoot":"","sources":["../../src/task-strategies/canonicalNarrixModes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,+BAA+B,EAC/B,eAAe,EACf,oCAAoC,GACrC,MAAM,gBAAgB,CAAC;AAGxB;;;GAGG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC;QACE,WAAW,EAAE,KAAK;QAClB,KAAK,EAAE,KAAK;QACZ,WAAW,EACT,yJAAyJ;QAC3J,MAAM,EAAE,QAAQ;QAChB,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,CAAC,oCAAoC,CAAC;KAClD;IACD;QACE,WAAW,EAAE,cAAc;QAC3B,KAAK,EAAE,cAAc;QACrB,WAAW,EACT,+HAA+H;QACjI,MAAM,EAAE,QAAQ;QAChB,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,CAAC,oCAAoC,CAAC;KAClD;IACD;QACE,WAAW,EAAE,SAAS;QACtB,KAAK,EAAE,sBAAsB;QAC7B,WAAW,EACT,8KAA8K;QAChL,MAAM,EAAE,QAAQ;QAChB,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,CAAC,oCAAoC,CAAC;KAClD;CAC0D,CAAC;AAI9D,MAAM,CAAC,MAAM,0BAA0B,GAA6B,sBAAsB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;AAErH,MAAM,CAAC,MAAM,uBAAuB,GAAG,+BAA+B,CAAC;AAEvE,MAAM,CAAC,MAAM,8BAA8B,GAAG,eAAe,CAAC"}

package/dist/task-strategies/canonicalTaskStrategies.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Pre–core task strategies: what feeds the synthesis PRE step (`synthesisInputStrategy` on `SynthesisConfig`).
+ */
+export declare const CANONICAL_PRE_CORE_TASK_STRATEGIES: readonly [{
+    readonly strategyKey: "policy";
+    readonly title: "Policy-driven sources";
+    readonly description: "Use contextSourcePolicy with narrix, web, and memory composition (default synthesized-context input).";
+    readonly domain: "synthesis";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["pre-core-task", "synthesized-context"];
+}, {
+    readonly strategyKey: "execution-memory-only";
+    readonly title: "Execution memory only";
+    readonly description: "Synthesize from executionMemory only.";
+    readonly domain: "synthesis";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["pre-core-task", "synthesized-context"];
+}, {
+    readonly strategyKey: "job-memory-only";
+    readonly title: "Job memory only";
+    readonly description: "Synthesize from jobMemory only.";
+    readonly domain: "synthesis";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["pre-core-task", "synthesized-context"];
+}, {
+    readonly strategyKey: "task-memory-only";
+    readonly title: "Task memory only";
+    readonly description: "Synthesize from taskMemory only.";
+    readonly domain: "synthesis";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["pre-core-task", "synthesized-context"];
+}, {
+    readonly strategyKey: "full-memory-bundle";
+    readonly title: "Full memory bundle";
+    readonly description: "Synthesize from jobMemory, taskMemory, and executionMemory together.";
+    readonly domain: "synthesis";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["pre-core-task", "synthesized-context"];
+}];
+/**
+ * Post–core task strategies: e.g. `AuditConfig.selectionStrategy` after the main task output exists.
+ */
+export declare const CANONICAL_POST_CORE_TASK_STRATEGIES: readonly [{
+    readonly strategyKey: "best";
+    readonly title: "Best candidate";
+    readonly description: "Prefer the single highest-scoring candidate from audit checks (default). Does not run cross-candidate synthesis.";
+    readonly domain: "audit";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["post-core-tasks", "audit"];
+}, {
+    readonly strategyKey: "synthesis";
+    readonly title: "Synthesize across candidates";
+    readonly description: "When multiple strong candidates exist, run an additional synthesis pass across them (see audit POST step).";
+    readonly domain: "audit";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["post-core-tasks", "audit"];
+}];
+/** @deprecated Use {@link CANONICAL_PRE_CORE_TASK_STRATEGIES}. */
+export declare const CANONICAL_TASK_STRATEGIES: readonly [{
+    readonly strategyKey: "policy";
+    readonly title: "Policy-driven sources";
+    readonly description: "Use contextSourcePolicy with narrix, web, and memory composition (default synthesized-context input).";
+    readonly domain: "synthesis";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["pre-core-task", "synthesized-context"];
+}, {
+    readonly strategyKey: "execution-memory-only";
+    readonly title: "Execution memory only";
+    readonly description: "Synthesize from executionMemory only.";
+    readonly domain: "synthesis";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["pre-core-task", "synthesized-context"];
+}, {
+    readonly strategyKey: "job-memory-only";
+    readonly title: "Job memory only";
+    readonly description: "Synthesize from jobMemory only.";
+    readonly domain: "synthesis";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["pre-core-task", "synthesized-context"];
+}, {
+    readonly strategyKey: "task-memory-only";
+    readonly title: "Task memory only";
+    readonly description: "Synthesize from taskMemory only.";
+    readonly domain: "synthesis";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["pre-core-task", "synthesized-context"];
+}, {
+    readonly strategyKey: "full-memory-bundle";
+    readonly title: "Full memory bundle";
+    readonly description: "Synthesize from jobMemory, taskMemory, and executionMemory together.";
+    readonly domain: "synthesis";
+    readonly multiSelectable: false;
+    readonly appliesTo: ["pre-core-task", "synthesized-context"];
+}];
+export type TaskStrategyKey = (typeof CANONICAL_PRE_CORE_TASK_STRATEGIES)[number]["strategyKey"];
+export type PostCoreTaskStrategyKey = (typeof CANONICAL_POST_CORE_TASK_STRATEGIES)[number]["strategyKey"];
+export declare const CANONICAL_TASK_STRATEGY_KEYS: readonly TaskStrategyKey[];
+export declare const CANONICAL_POST_CORE_TASK_STRATEGY_KEYS: readonly PostCoreTaskStrategyKey[];
+export declare const TASK_STRATEGIES_PRE_CATALOG_ID: "ai-task-strategies-pre";
+export declare const TASK_STRATEGIES_POST_CATALOG_ID: "ai-task-strategies-post";
+/** @deprecated Use {@link TASK_STRATEGIES_PRE_CATALOG_ID}. */
+export declare const TASK_STRATEGIES_CATALOG_ID: "ai-task-strategies-pre";
+export declare const TASK_STRATEGIES_APP_ID: "ai-tasks";
+//# sourceMappingURL=canonicalTaskStrategies.d.ts.map

package/dist/task-strategies/canonicalTaskStrategies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalTaskStrategies.d.ts","sourceRoot":"","sources":["../../src/task-strategies/canonicalTaskStrategies.ts"],"names":[],"mappings":"AAWA;;GAEG;AACH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0Cc,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;EAmBa,CAAC;AAE9D,kEAAkE;AAClE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqC,CAAC;AAE5E,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,kCAAkC,CAAC,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,CAAC;AAEjG,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,mCAAmC,CAAC,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,CAAC;AAE1G,eAAO,MAAM,4BAA4B,EAAE,SAAS,eAAe,EACL,CAAC;AAE/D,eAAO,MAAM,sCAAsC,EAAE,SAAS,uBAAuB,EACtB,CAAC;AAEhE,eAAO,MAAM,8BAA8B,0BAAoC,CAAC;AAChF,eAAO,MAAM,+BAA+B,2BAAqC,CAAC;AAElF,8DAA8D;AAC9D,eAAO,MAAM,0BAA0B,0BAAoC,CAAC;AAE5E,eAAO,MAAM,sBAAsB,YAAkB,CAAC"}

package/dist/task-strategies/canonicalTaskStrategies.js

@@ -0,0 +1,77 @@
+import { AI_TASK_POST_STRATEGIES_CATALOG_ID, AI_TASK_PRE_STRATEGIES_CATALOG_ID, AI_TASKS_APP_ID, TASK_STRATEGY_APPLIES_TO_AUDIT, TASK_STRATEGY_APPLIES_TO_POST_CORE_TASKS, TASK_STRATEGY_APPLIES_TO_PRE_CORE_TASK, TASK_STRATEGY_APPLIES_TO_SYNTHESIZED_CONTEXT, } from "./constants.js";
+/**
+ * Pre–core task strategies: what feeds the synthesis PRE step (`synthesisInputStrategy` on `SynthesisConfig`).
+ */
+export const CANONICAL_PRE_CORE_TASK_STRATEGIES = [
+    {
+        strategyKey: "policy",
+        title: "Policy-driven sources",
+        description: "Use contextSourcePolicy with narrix, web, and memory composition (default synthesized-context input).",
+        domain: "synthesis",
+        multiSelectable: false,
+        appliesTo: [TASK_STRATEGY_APPLIES_TO_PRE_CORE_TASK, TASK_STRATEGY_APPLIES_TO_SYNTHESIZED_CONTEXT],
+    },
+    {
+        strategyKey: "execution-memory-only",
+        title: "Execution memory only",
+        description: "Synthesize from executionMemory only.",
+        domain: "synthesis",
+        multiSelectable: false,
+        appliesTo: [TASK_STRATEGY_APPLIES_TO_PRE_CORE_TASK, TASK_STRATEGY_APPLIES_TO_SYNTHESIZED_CONTEXT],
+    },
+    {
+        strategyKey: "job-memory-only",
+        title: "Job memory only",
+        description: "Synthesize from jobMemory only.",
+        domain: "synthesis",
+        multiSelectable: false,
+        appliesTo: [TASK_STRATEGY_APPLIES_TO_PRE_CORE_TASK, TASK_STRATEGY_APPLIES_TO_SYNTHESIZED_CONTEXT],
+    },
+    {
+        strategyKey: "task-memory-only",
+        title: "Task memory only",
+        description: "Synthesize from taskMemory only.",
+        domain: "synthesis",
+        multiSelectable: false,
+        appliesTo: [TASK_STRATEGY_APPLIES_TO_PRE_CORE_TASK, TASK_STRATEGY_APPLIES_TO_SYNTHESIZED_CONTEXT],
+    },
+    {
+        strategyKey: "full-memory-bundle",
+        title: "Full memory bundle",
+        description: "Synthesize from jobMemory, taskMemory, and executionMemory together.",
+        domain: "synthesis",
+        multiSelectable: false,
+        appliesTo: [TASK_STRATEGY_APPLIES_TO_PRE_CORE_TASK, TASK_STRATEGY_APPLIES_TO_SYNTHESIZED_CONTEXT],
+    },
+];
+/**
+ * Post–core task strategies: e.g. `AuditConfig.selectionStrategy` after the main task output exists.
+ */
+export const CANONICAL_POST_CORE_TASK_STRATEGIES = [
+    {
+        strategyKey: "best",
+        title: "Best candidate",
+        description: "Prefer the single highest-scoring candidate from audit checks (default). Does not run cross-candidate synthesis.",
+        domain: "audit",
+        multiSelectable: false,
+        appliesTo: [TASK_STRATEGY_APPLIES_TO_POST_CORE_TASKS, TASK_STRATEGY_APPLIES_TO_AUDIT],
+    },
+    {
+        strategyKey: "synthesis",
+        title: "Synthesize across candidates",
+        description: "When multiple strong candidates exist, run an additional synthesis pass across them (see audit POST step).",
+        domain: "audit",
+        multiSelectable: false,
+        appliesTo: [TASK_STRATEGY_APPLIES_TO_POST_CORE_TASKS, TASK_STRATEGY_APPLIES_TO_AUDIT],
+    },
+];
+/** @deprecated Use {@link CANONICAL_PRE_CORE_TASK_STRATEGIES}. */
+export const CANONICAL_TASK_STRATEGIES = CANONICAL_PRE_CORE_TASK_STRATEGIES;
+export const CANONICAL_TASK_STRATEGY_KEYS = CANONICAL_PRE_CORE_TASK_STRATEGIES.map((s) => s.strategyKey);
+export const CANONICAL_POST_CORE_TASK_STRATEGY_KEYS = CANONICAL_POST_CORE_TASK_STRATEGIES.map((s) => s.strategyKey);
+export const TASK_STRATEGIES_PRE_CATALOG_ID = AI_TASK_PRE_STRATEGIES_CATALOG_ID;
+export const TASK_STRATEGIES_POST_CATALOG_ID = AI_TASK_POST_STRATEGIES_CATALOG_ID;
+/** @deprecated Use {@link TASK_STRATEGIES_PRE_CATALOG_ID}. */
+export const TASK_STRATEGIES_CATALOG_ID = AI_TASK_PRE_STRATEGIES_CATALOG_ID;
+export const TASK_STRATEGIES_APP_ID = AI_TASKS_APP_ID;
+//# sourceMappingURL=canonicalTaskStrategies.js.map

package/dist/task-strategies/canonicalTaskStrategies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalTaskStrategies.js","sourceRoot":"","sources":["../../src/task-strategies/canonicalTaskStrategies.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kCAAkC,EAClC,iCAAiC,EACjC,eAAe,EACf,8BAA8B,EAC9B,wCAAwC,EACxC,sCAAsC,EACtC,4CAA4C,GAC7C,MAAM,gBAAgB,CAAC;AAGxB;;GAEG;AACH,MAAM,CAAC,MAAM,kCAAkC,GAAG;IAChD;QACE,WAAW,EAAE,QAAQ;QACrB,KAAK,EAAE,uBAAuB;QAC9B,WAAW,EACT,uGAAuG;QACzG,MAAM,EAAE,WAAW;QACnB,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,CAAC,sCAAsC,EAAE,4CAA4C,CAAC;KAClG;IACD;QACE,WAAW,EAAE,uBAAuB;QACpC,KAAK,EAAE,uBAAuB;QAC9B,WAAW,EAAE,uCAAuC;QACpD,MAAM,EAAE,WAAW;QACnB,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,CAAC,sCAAsC,EAAE,4CAA4C,CAAC;KAClG;IACD;QACE,WAAW,EAAE,iBAAiB;QAC9B,KAAK,EAAE,iBAAiB;QACxB,WAAW,EAAE,iCAAiC;QAC9C,MAAM,EAAE,WAAW;QACnB,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,CAAC,sCAAsC,EAAE,4CAA4C,CAAC;KAClG;IACD;QACE,WAAW,EAAE,kBAAkB;QAC/B,KAAK,EAAE,kBAAkB;QACzB,WAAW,EAAE,kCAAkC;QAC/C,MAAM,EAAE,WAAW;QACnB,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,CAAC,sCAAsC,EAAE,4CAA4C,CAAC;KAClG;IACD;QACE,WAAW,EAAE,oBAAoB;QACjC,KAAK,EAAE,oBAAoB;QAC3B,WAAW,EAAE,sEAAsE;QACnF,MAAM,EAAE,WAAW;QACnB,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,CAAC,sCAAsC,EAAE,4CAA4C,CAAC;KAClG;CAC0D,CAAC;AAE9D;;GAEG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG;IACjD;QACE,WAAW,EAAE,MAAM;QACnB,KAAK,EAAE,gBAAgB;QACvB,WAAW,EACT,kHAAkH;QACpH,MAAM,EAAE,OAAO;QACf,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,CAAC,wCAAwC,EAAE,8BAA8B,CAAC;KACtF;IACD;QACE,WAAW,EAAE,WAAW;QACxB,KAAK,EAAE,8BAA8B;QACrC,WAAW,EACT,4GAA4G;QAC9G,MAAM,EAAE,OAAO;QACf,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,CAAC,wCAAwC,EAAE,8BAA8B,CAAC;KACtF;CAC0D,CAAC;AAE9D,kEAAkE;AAClE,MAAM,CAAC,MAAM,yBAAyB,GAAG,kCAAkC,CAAC;AAM5E,MAAM,CAAC,MAAM,4BAA4B,GACvC,kCAAkC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;AAE/D,MAAM,CAAC,MAAM,sCAAsC,GACjD,mCAAmC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;AAEhE,MAAM,CAAC,MAAM,8BAA8B,GAAG,iCAAiC,CAAC;AAChF,MAAM,CAAC,MAAM,+BAA+B,GAAG,kCAAkC,CAAC;AAElF,8DAA8D;AAC9D,MAAM,CAAC,MAAM,0BAA0B,GAAG,iCAAiC,CAAC;AAE5E,MAAM,CAAC,MAAM,sBAAsB,GAAG,eAAe,CAAC"}

package/dist/task-strategies/cataloxCatalogViews.d.ts

@@ -0,0 +1,55 @@
+import type { AppCatalogBootstrap, AppCatalogEntry, Catalox, CataloxContext, CatalogDescriptor } from "@x12i/catalox";
+import { AI_TASK_EXECUTION_STRATEGIES_CATALOG_ID, AI_TASK_EXECUTION_STRATEGY_CATALOG_ID, AI_TASK_INPUT_STRATEGIES_CATALOG_ID, AI_TASK_MAIN_EXECUTION_WRAPPERS_CATALOG_ID, AI_TASK_NARRIX_MODES_CATALOG_ID, AI_TASK_POST_STRATEGIES_CATALOG_ID, AI_TASK_PRE_STRATEGIES_CATALOG_ID, AI_TASKS_APP_ID } from "./constants.js";
+import type { ListTaskStrategiesResult } from "./listAiTaskStrategies.js";
+/**
+ * Default {@link CataloxContext} for reads scoped to the **ai-tasks** app (task-strategy catalogs).
+ */
+export declare function defaultAiTasksCataloxContext(overrides?: Partial<CataloxContext>): CataloxContext;
+/**
+ * Lists catalog rows bound to **`ai-tasks`** (discovery: id, label, access, source mode).
+ * Thin wrapper over {@link Catalox.listAppCatalogs}.
+ */
+export declare function listAiTasksAppCatalogs(catalox: Catalox, context?: CataloxContext, input?: {
+    includeDisabled?: boolean;
+    includeHidden?: boolean;
+}): Promise<AppCatalogEntry[]>;
+/**
+ * Bootstrap payload: every **descriptor** the **`ai-tasks`** app can access (capabilities, identity, query fields).
+ * Thin wrapper over {@link Catalox.getAppCatalogBootstrap}.
+ */
+export declare function getAiTasksAppCatalogBootstrap(catalox: Catalox, context?: CataloxContext): Promise<AppCatalogBootstrap>;
+/**
+ * Descriptor for one strategy catalog (pre or post).
+ */
+export declare function getAiTasksTaskStrategiesCatalogDescriptor(catalox: Catalox, catalogId: typeof AI_TASK_PRE_STRATEGIES_CATALOG_ID | typeof AI_TASK_POST_STRATEGIES_CATALOG_ID | typeof AI_TASK_INPUT_STRATEGIES_CATALOG_ID | typeof AI_TASK_EXECUTION_STRATEGY_CATALOG_ID | typeof AI_TASK_EXECUTION_STRATEGIES_CATALOG_ID | typeof AI_TASK_MAIN_EXECUTION_WRAPPERS_CATALOG_ID | typeof AI_TASK_NARRIX_MODES_CATALOG_ID, context?: CataloxContext): Promise<CatalogDescriptor | null>;
+export type AiTasksTaskStrategiesCatalogSnapshot = {
+    appId: typeof AI_TASKS_APP_ID;
+    preCatalogId: typeof AI_TASK_PRE_STRATEGIES_CATALOG_ID;
+    postCatalogId: typeof AI_TASK_POST_STRATEGIES_CATALOG_ID;
+    inputCatalogId: typeof AI_TASK_INPUT_STRATEGIES_CATALOG_ID;
+    executionStrategyCatalogId: typeof AI_TASK_EXECUTION_STRATEGY_CATALOG_ID;
+    executionCatalogId: typeof AI_TASK_EXECUTION_STRATEGIES_CATALOG_ID;
+    mainExecutionWrappersCatalogId: typeof AI_TASK_MAIN_EXECUTION_WRAPPERS_CATALOG_ID;
+    narrixModesCatalogId: typeof AI_TASK_NARRIX_MODES_CATALOG_ID;
+    pre: ListTaskStrategiesResult;
+    post: ListTaskStrategiesResult;
+    input: ListTaskStrategiesResult;
+    executionStrategy: ListTaskStrategiesResult;
+    execution: ListTaskStrategiesResult;
+    mainExecutionWrappers: ListTaskStrategiesResult;
+    narrixModes: ListTaskStrategiesResult;
+};
+/**
+ * Loads every **ai-tasks** strategy catalog in one call (normalized `TaskStrategyItemData` per slice).
+ * For raw {@link UnifiedCatalogItem} rows, use {@link Catalox.listCatalogItems} or {@link Catalox.listCatalogItemsWithOutcome} with the catalog ids above.
+ */
+export declare function getAiTasksTaskStrategiesCatalogSnapshot(catalox: Catalox, context?: CataloxContext, query?: {
+    limitPre?: number;
+    limitPost?: number;
+    limitInput?: number;
+    limitExecutionStrategy?: number;
+    limitExecution?: number;
+    limitMainExecutionWrappers?: number;
+    limitNarrixModes?: number;
+}): Promise<AiTasksTaskStrategiesCatalogSnapshot>;
+//# sourceMappingURL=cataloxCatalogViews.d.ts.map

package/dist/task-strategies/cataloxCatalogViews.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cataloxCatalogViews.d.ts","sourceRoot":"","sources":["../../src/task-strategies/cataloxCatalogViews.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,eAAe,EACf,OAAO,EACP,cAAc,EACd,iBAAiB,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,uCAAuC,EACvC,qCAAqC,EACrC,mCAAmC,EACnC,0CAA0C,EAC1C,+BAA+B,EAC/B,kCAAkC,EAClC,iCAAiC,EACjC,eAAe,EAChB,MAAM,gBAAgB,CAAC;AAUxB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAE1E;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,cAAc,CAEhG;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,OAAO,EAChB,OAAO,CAAC,EAAE,cAAc,EACxB,KAAK,CAAC,EAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,GAC7D,OAAO,CAAC,eAAe,EAAE,CAAC,CAG5B;AAED;;;GAGG;AACH,wBAAsB,6BAA6B,CACjD,OAAO,EAAE,OAAO,EAChB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,mBAAmB,CAAC,CAG9B;AAED;;GAEG;AACH,wBAAsB,yCAAyC,CAC7D,OAAO,EAAE,OAAO,EAChB,SAAS,EACL,OAAO,iCAAiC,GACxC,OAAO,kCAAkC,GACzC,OAAO,mCAAmC,GAC1C,OAAO,qCAAqC,GAC5C,OAAO,uCAAuC,GAC9C,OAAO,0CAA0C,GACjD,OAAO,+BAA+B,EAC1C,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAGnC;AAED,MAAM,MAAM,oCAAoC,GAAG;IACjD,KAAK,EAAE,OAAO,eAAe,CAAC;IAC9B,YAAY,EAAE,OAAO,iCAAiC,CAAC;IACvD,aAAa,EAAE,OAAO,kCAAkC,CAAC;IACzD,cAAc,EAAE,OAAO,mCAAmC,CAAC;IAC3D,0BAA0B,EAAE,OAAO,qCAAqC,CAAC;IACzE,kBAAkB,EAAE,OAAO,uCAAuC,CAAC;IACnE,8BAA8B,EAAE,OAAO,0CAA0C,CAAC;IAClF,oBAAoB,EAAE,OAAO,+BAA+B,CAAC;IAC7D,GAAG,EAAE,wBAAwB,CAAC;IAC9B,IAAI,EAAE,wBAAwB,CAAC;IAC/B,KAAK,EAAE,wBAAwB,CAAC;IAChC,iBAAiB,EAAE,wBAAwB,CAAC;IAC5C,SAAS,EAAE,wBAAwB,CAAC;IACpC,qBAAqB,EAAE,wBAAwB,CAAC;IAChD,WAAW,EAAE,wBAAwB,CAAC;CACvC,CAAC;AAEF;;;GAGG;AACH,wBAAsB,uCAAuC,CAC3D,OAAO,EAAE,OAAO,EAChB,OAAO,CAAC,EAAE,cAAc,EACxB,KAAK,CAAC,EAAE;IACN,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,GACA,OAAO,CAAC,oCAAoC,CAAC,CA4B/C"}