hoi4-agent-tools 3.0.8 → 3.1.0

package/dist/hoi4_agent_tools/probability/trigger-evaluator.js

@@ -1,287 +1 @@
-import { assignments, astPathFor, firstScalar, nodeLocation, } from '../core/source/index.js';
-import { resolveScopeContext, rootScopeContext, rootStateValue, scopeIdentity, scopeStateValue, } from './scenario-state.js';
-function combineAnd(values) {
-    if (values.includes('false'))
-        return 'false';
-    return values.includes('unresolved') ? 'unresolved' : 'true';
-}
-function combineOr(values) {
-    if (values.includes('true'))
-        return 'true';
-    return values.includes('unresolved') ? 'unresolved' : 'false';
-}
-function invert(value) {
-    return value === 'true' ? 'false' : value === 'false' ? 'true' : 'unresolved';
-}
-function bool(value) {
-    if (typeof value === 'boolean')
-        return value;
-    if (value === 'yes' || value === 'true')
-        return true;
-    if (value === 'no' || value === 'false')
-        return false;
-    return undefined;
-}
-function numeric(value) {
-    if (typeof value === 'number' && Number.isFinite(value))
-        return value;
-    if (typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value)))
-        return Number(value);
-    return undefined;
-}
-function compare(left, right, operator) {
-    if (typeof left === 'number' && typeof right === 'number') {
-        if (operator === '>')
-            return left > right;
-        if (operator === '<')
-            return left < right;
-    }
-    return operator === '!=' ? left !== right : left === right;
-}
-function unresolved(assignment, candidate, reason) {
-    return {
-        state: 'unresolved',
-        unresolved: [
-            {
-                code: 'TRIGGER_UNRESOLVED',
-                message: reason,
-                path: assignment.key.value,
-                candidateId: candidate.id,
-                ...(candidate.provenance[0] === undefined ? {} : { provenance: candidate.provenance[0] }),
-            },
-        ],
-    };
-}
-function evaluateCheckVariable(block, scenario, candidate, assignment, scopeContext) {
-    const variable = firstScalar(block, 'var')?.value;
-    const target = firstScalar(block, 'value')?.value;
-    if (variable === undefined || target === undefined)
-        return unresolved(assignment, candidate, 'check_variable requires declared var and value');
-    const left = scopeStateValue(scenario, `variable.${variable}`, scopeContext) ??
-        scopeStateValue(scenario, variable, scopeContext);
-    const leftNumber = numeric(left);
-    const rightNumber = numeric(target);
-    if (leftNumber === undefined || rightNumber === undefined)
-        return unresolved(assignment, candidate, `Scenario does not declare numeric variable ${variable}`);
-    const compareName = firstScalar(block, 'compare')?.value ?? 'equals';
-    const result = compareName === 'greater_than'
-        ? leftNumber > rightNumber
-        : compareName === 'greater_than_or_equals'
-            ? leftNumber >= rightNumber
-            : compareName === 'less_than'
-                ? leftNumber < rightNumber
-                : compareName === 'less_than_or_equals'
-                    ? leftNumber <= rightNumber
-                    : compareName === 'not_equals'
-                        ? leftNumber !== rightNumber
-                        : leftNumber === rightNumber;
-    return { state: result ? 'true' : 'false', unresolved: [] };
-}
-function evaluateAssignmentCore(assignment, scenario, candidate, definitions, helperStack, scopeContext) {
-    const key = assignment.key.value;
-    if (assignment.value.type === 'block') {
-        if (key === 'AND')
-            return evaluateTriggerBlock(assignment.value, scenario, candidate, definitions, helperStack, scopeContext);
-        if (key === 'OR') {
-            const children = assignments(assignment.value).map((child) => evaluateAssignment(child, scenario, candidate, definitions, helperStack, scopeContext));
-            return {
-                state: combineOr(children.map(({ state }) => state)),
-                unresolved: children.flatMap(({ unresolved: items }) => items),
-                helperProvenance: children.flatMap(({ helperProvenance }) => helperProvenance ?? []),
-            };
-        }
-        if (key === 'NOT' || key === 'NOR' || key === 'NAND') {
-            const children = assignments(assignment.value).map((child) => evaluateAssignment(child, scenario, candidate, definitions, helperStack, scopeContext));
-            const base = key === 'NAND'
-                ? combineAnd(children.map(({ state }) => state))
-                : combineOr(children.map(({ state }) => state));
-            return {
-                state: invert(base),
-                unresolved: children.flatMap(({ unresolved: items }) => items),
-                helperProvenance: children.flatMap(({ helperProvenance }) => helperProvenance ?? []),
-            };
-        }
-        if (key === 'check_variable')
-            return evaluateCheckVariable(assignment.value, scenario, candidate, assignment, scopeContext);
-        if (key === 'is_in_array' || key === 'is_variable_in_array') {
-            const arrayId = firstScalar(assignment.value, 'array')?.value;
-            const declaredValue = firstScalar(assignment.value, 'value')?.value;
-            if (arrayId === undefined || declaredValue === undefined)
-                return unresolved(assignment, candidate, `${key} requires array and value`);
-            const array = scopeStateValue(scenario, `array.${arrayId}`, scopeContext) ??
-                rootStateValue(scenario, `array.${arrayId}`);
-            if (!Array.isArray(array))
-                return unresolved(assignment, candidate, `Scenario does not declare array ${arrayId}`);
-            const compared = ['THIS', 'ROOT', 'PREV'].includes(declaredValue.toUpperCase()) ||
-                resolveScopeContext(scenario, declaredValue, scopeContext) !== undefined
-                ? scopeIdentity(resolveScopeContext(scenario, declaredValue, scopeContext) ?? scopeContext)
-                : (scopeStateValue(scenario, declaredValue, scopeContext) ?? declaredValue);
-            return { state: array.includes(compared) ? 'true' : 'false', unresolved: [] };
-        }
-        const resolvedScope = resolveScopeContext(scenario, key, scopeContext);
-        if (resolvedScope !== undefined)
-            return evaluateTriggerBlock(assignment.value, scenario, candidate, definitions, helperStack, resolvedScope);
-        const helper = definitions.scriptedTriggers.get(key);
-        if (helper !== undefined) {
-            if (helperStack.includes(key))
-                return unresolved(assignment, candidate, `Scripted trigger recursion detected at ${key}`);
-            if (assignments(assignment.value).length > 0)
-                return unresolved(assignment, candidate, `Parameterized scripted trigger ${key} is not expanded without declared arguments`);
-            const helperProvenance = {
-                path: helper.file.displayPath,
-                rootKind: helper.file.rootKind,
-                loadOrder: helper.file.loadOrder,
-                sourceHash: helper.file.sha256,
-                location: nodeLocation(helper.document, helper.node, key),
-                ...(astPathFor(helper.document, helper.node) === undefined
-                    ? {}
-                    : { astPath: astPathFor(helper.document, helper.node) }),
-                symbol: key,
-                helperChain: [...helperStack, key],
-            };
-            const evaluated = evaluateTriggerBlock(helper.value, scenario, {
-                ...candidate,
-                document: helper.document,
-                provenance: [helperProvenance, ...candidate.provenance],
-            }, definitions, [...helperStack, key], scopeContext);
-            return {
-                ...evaluated,
-                helperProvenance: [helperProvenance, ...(evaluated.helperProvenance ?? [])],
-            };
-        }
-        const declaredScope = bool(rootStateValue(scenario, `scope.${key}`));
-        if (declaredScope !== undefined)
-            return { state: declaredScope ? 'true' : 'false', unresolved: [] };
-        return unresolved(assignment, candidate, `Scoped or compound trigger ${key} is not declared by the scenario`);
-    }
-    const right = assignment.value.value;
-    if (key === 'always') {
-        const value = bool(right);
-        return value === undefined
-            ? unresolved(assignment, candidate, 'always trigger is not boolean')
-            : { state: value ? 'true' : 'false', unresolved: [] };
-    }
-    if (key === 'has_country_flag' || key === 'has_global_flag' || key === 'has_state_flag') {
-        const flags = scopeContext.expression === 'ROOT' ? scenario.flags : scopeContext.binding.flags;
-        return { state: flags?.includes(right) === true ? 'true' : 'false', unresolved: [] };
-    }
-    if (key === 'has_event_target') {
-        const eventTargets = scopeContext.binding.eventTargets ?? scenario.eventTargets;
-        return {
-            state: Object.hasOwn(eventTargets ?? {}, right) ? 'true' : 'false',
-            unresolved: [],
-        };
-    }
-    if (key === 'tag' || key === 'original_tag') {
-        const actor = scopeContext.expression === 'ROOT'
-            ? scenario.actor
-            : (scopeContext.binding.actor ?? scopeContext.binding.id);
-        if (actor === undefined)
-            return unresolved(assignment, candidate, `Scenario does not declare actor for ${key}`);
-        return {
-            state: compare(actor, right, assignment.operator.text) ? 'true' : 'false',
-            unresolved: [],
-        };
-    }
-    if (key === 'date') {
-        if (scenario.date === undefined)
-            return unresolved(assignment, candidate, 'Scenario does not declare date');
-        const leftDate = Number(scenario.date.replaceAll('.', ''));
-        const rightDate = Number(right.replaceAll('.', ''));
-        if (!Number.isFinite(leftDate) || !Number.isFinite(rightDate))
-            return unresolved(assignment, candidate, 'Date comparison is not numeric');
-        return {
-            state: compare(leftDate, rightDate, assignment.operator.text) ? 'true' : 'false',
-            unresolved: [],
-        };
-    }
-    const helper = definitions.scriptedTriggers.get(key);
-    if (helper !== undefined && bool(right) === true) {
-        if (helperStack.includes(key))
-            return unresolved(assignment, candidate, `Scripted trigger recursion detected at ${key}`);
-        const helperProvenance = {
-            path: helper.file.displayPath,
-            rootKind: helper.file.rootKind,
-            loadOrder: helper.file.loadOrder,
-            sourceHash: helper.file.sha256,
-            location: nodeLocation(helper.document, helper.node, key),
-            ...(astPathFor(helper.document, helper.node) === undefined
-                ? {}
-                : { astPath: astPathFor(helper.document, helper.node) }),
-            symbol: key,
-            helperChain: [...helperStack, key],
-        };
-        const evaluated = evaluateTriggerBlock(helper.value, scenario, {
-            ...candidate,
-            document: helper.document,
-            provenance: [helperProvenance, ...candidate.provenance],
-        }, definitions, [...helperStack, key], scopeContext);
-        return {
-            ...evaluated,
-            helperProvenance: [helperProvenance, ...(evaluated.helperProvenance ?? [])],
-        };
-    }
-    const declared = scopeStateValue(scenario, key, scopeContext);
-    if (declared === undefined)
-        return unresolved(assignment, candidate, `Scenario does not declare trigger ${key}`);
-    const expectedBoolean = bool(right);
-    const actualBoolean = bool(declared);
-    if (expectedBoolean !== undefined && actualBoolean !== undefined)
-        return { state: expectedBoolean === actualBoolean ? 'true' : 'false', unresolved: [] };
-    const leftNumber = numeric(declared);
-    const rightNumber = numeric(right);
-    if (leftNumber !== undefined && rightNumber !== undefined)
-        return {
-            state: compare(leftNumber, rightNumber, assignment.operator.text) ? 'true' : 'false',
-            unresolved: [],
-        };
-    if (typeof declared === 'string')
-        return {
-            state: compare(declared, right, assignment.operator.text) ? 'true' : 'false',
-            unresolved: [],
-        };
-    return unresolved(assignment, candidate, `Trigger ${key} cannot compare the declared scenario value`);
-}
-function evaluateAssignment(assignment, scenario, candidate, definitions, helperStack, scopeContext) {
-    const evaluated = evaluateAssignmentCore(assignment, scenario, candidate, definitions, helperStack, scopeContext);
-    const source = candidate.provenance[0];
-    const provenance = candidate.document === undefined || source === undefined
-        ? source
-        : {
-            ...source,
-            location: nodeLocation(candidate.document, assignment, assignment.key.value),
-            ...(astPathFor(candidate.document, assignment) === undefined
-                ? {}
-                : { astPath: astPathFor(candidate.document, assignment) }),
-            symbol: assignment.key.value,
-        };
-    const expression = assignment.value.type === 'scalar'
-        ? `${assignment.key.value} ${assignment.operator.text} ${assignment.value.value}`
-        : assignment.key.value;
-    return {
-        ...evaluated,
-        trace: [
-            {
-                operation: 'eligibility',
-                expression,
-                applied: evaluated.state,
-                ...(provenance === undefined ? {} : { provenance }),
-            },
-            ...(evaluated.trace ?? []),
-        ],
-    };
-}
-export function evaluateTriggerBlock(block, scenario, candidate, definitions, helperStack = [], scopeContext = rootScopeContext(scenario)) {
-    const override = scenario.candidateOverrides?.[candidate.id];
-    if (override !== undefined)
-        return { state: override ? 'true' : 'false', unresolved: [] };
-    if (block === undefined)
-        return { state: 'true', unresolved: [] };
-    const children = assignments(block).map((assignment) => evaluateAssignment(assignment, scenario, candidate, definitions, helperStack, scopeContext));
-    return {
-        state: combineAnd(children.map(({ state }) => state)),
-        unresolved: children.flatMap(({ unresolved: items }) => items),
-        helperProvenance: children.flatMap(({ helperProvenance }) => helperProvenance ?? []),
-        trace: children.flatMap(({ trace }) => trace ?? []),
-    };
-}
+export { evaluateTriggerBlock } from '../core/condition-evaluator.js';

package/dist/hoi4_agent_tools/schemas/common.js

@@ -4,6 +4,8 @@ export const workspaceIdSchema = z
     .string()
     .regex(/^[a-z][a-z0-9_-]{0,63}$/u)
     .default('current');
+/** Caller-stable deduplication key for resumable background mutations. */
+export const backgroundRequestKeySchema = z.string().min(1).max(256);
 const diagnosticCodeSchema = z.string().min(1).max(256);
 const diagnosticMessageSchema = z.string().max(4096);
 const sourceDisplayPathSchema = z.string().min(1).max(4096);

package/dist/hoi4_agent_tools/schemas/event.js

@@ -1,6 +1,7 @@
 import { z } from 'zod/v4';
 import { SOURCE_MAX_BYTES } from '../core/source/index.js';
-import { workspaceRelativePathSchema } from './common.js';
+import { workspaceIdSchema, workspaceRelativePathSchema } from './common.js';
+import { helperExpansionRequestSchema, validateHelperExpansionMode } from './helper-expansion.js';
 const eventIdSchema = z.string().min(1).max(256);
 const eventSourcePathSchema = z.string().min(1).max(1024);
 const eventNodeIdSchema = z.string().min(1).max(1024);
@@ -13,6 +14,7 @@ export const eventInspectModeSchema = z.enum([
     'state_flow',
     'lint',
     'impact',
+    'helper_expansion',
 ]);
 export const eventDirectionSchema = z.enum(['upstream', 'downstream', 'both']);
 export const eventRenderViewSchema = z.enum([
@@ -93,3 +95,72 @@ export const eventProposedSourceSchema = z
     expectedSourceHash: eventSha256Schema.optional(),
 })
     .strict();
+export function validateEventInspectRequest(value, context) {
+    validateHelperExpansionMode(value, context);
+    if (value.mode === 'trace' && value.selector === undefined)
+        context.addIssue({ code: 'custom', path: ['selector'], message: 'Trace requires selector' });
+    if (value.mode === 'explain_path' && (value.from === undefined || value.to === undefined))
+        context.addIssue({
+            code: 'custom',
+            path: value.from === undefined ? ['from'] : ['to'],
+            message: 'Path explanation requires from and to',
+        });
+    if (value.mode === 'impact' && value.impactSubject === undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['impactSubject'],
+            message: 'Impact analysis requires impactSubject',
+        });
+}
+export const eventInspectRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    mode: eventInspectModeSchema,
+    selector: eventSelectorSchema.optional(),
+    from: eventSelectorSchema.optional(),
+    to: eventSelectorSchema.optional(),
+    direction: eventDirectionSchema.optional(),
+    maxDepth: z.number().int().min(1).max(64).optional(),
+    maxNodes: z.number().int().min(1).max(5_000).optional(),
+    maxEdges: z.number().int().min(1).max(20_000).optional(),
+    expandHelpers: z.boolean().optional(),
+    stateSubject: eventStateSubjectSchema.optional(),
+    impactSubject: eventImpactSubjectSchema.optional(),
+    helperExpansion: helperExpansionRequestSchema.optional(),
+    refresh: z.boolean().optional(),
+})
+    .strict()
+    .superRefine(validateEventInspectRequest);
+export const eventRenderRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    view: eventRenderViewSchema,
+    selector: eventSelectorSchema.optional(),
+    direction: eventDirectionSchema.optional(),
+    maxDepth: z.number().int().min(1).max(64).optional(),
+    maxNodes: z.number().int().min(1).max(240).optional(),
+    expandHelpers: z.boolean().optional(),
+    includeHtml: z.boolean().optional(),
+    refresh: z.boolean().optional(),
+})
+    .strict();
+export function validateEventCompareRequest(value, context) {
+    if (value.after !== undefined && value.proposedSources !== undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['after'],
+            message: 'after and proposedSources are mutually exclusive',
+        });
+}
+export const eventCompareRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    before: eventGraphReferenceSchema.optional(),
+    after: eventGraphReferenceSchema.optional(),
+    proposedSources: z.array(eventProposedSourceSchema).min(1).max(64).optional(),
+    render: z.boolean().optional(),
+    maxRenderNodes: z.number().int().min(1).max(240).optional(),
+    refresh: z.boolean().optional(),
+})
+    .strict()
+    .superRefine(validateEventCompareRequest);

package/dist/hoi4_agent_tools/schemas/focus-requests.js

@@ -0,0 +1,189 @@
+import { z } from 'zod/v4';
+import { FOCUS_RENDER_MAX_OUTPUT_SCALE, FOCUS_RENDER_MIN_OUTPUT_SCALE } from '../focus/index.js';
+import { backgroundRequestKeySchema, workspaceIdSchema, workspaceRelativePathSchema, } from './common.js';
+import { continuousFocusPaletteSchema, focusLayoutSchema, focusTreePlanSchema } from './focus.js';
+function compact(schema, description) {
+    return z.unknown().describe(description).pipe(schema);
+}
+const compactFocusLayoutSchema = compact(focusLayoutSchema, 'Prior deterministic focus layout used to stabilize unchanged positions.');
+const compactFocusPlanSchema = compact(z.union([focusTreePlanSchema, continuousFocusPaletteSchema]), 'Complete national or continuous focus plan.');
+export const focusInspectRequestSchema = z
+    .object({
+    mode: z.enum(['national', 'continuous']).optional(),
+    workspaceId: workspaceIdSchema,
+    relativePath: workspaceRelativePathSchema.optional(),
+    treeId: z.string().min(1).max(256).optional(),
+    paletteId: z.string().min(1).max(256).optional(),
+    previous: compactFocusLayoutSchema.optional(),
+    laneSpacing: z.number().int().min(1).max(100).optional(),
+    nodeSpacing: z.number().int().min(1).max(100).optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    const mode = value.mode ?? 'national';
+    if (mode === 'national' && value.paletteId !== undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['paletteId'],
+            message: 'paletteId is only valid in continuous mode',
+        });
+    if (mode === 'continuous' && value.treeId !== undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['treeId'],
+            message: 'treeId is only valid in national mode',
+        });
+    if (mode === 'continuous') {
+        for (const field of ['previous', 'laneSpacing', 'nodeSpacing']) {
+            if (value[field] !== undefined)
+                context.addIssue({
+                    code: 'custom',
+                    path: [field],
+                    message: `${field} is only valid in national mode`,
+                });
+        }
+    }
+    if (value.previous !== undefined && value.treeId === undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['previous'],
+            message: 'previous requires treeId so it applies to exactly one tree',
+        });
+});
+export const focusRenderRequestSchema = z
+    .object({
+    mode: z.enum(['national', 'continuous']).optional(),
+    workspaceId: workspaceIdSchema,
+    relativePath: workspaceRelativePathSchema,
+    treeId: z.string().min(1).max(256).optional(),
+    paletteId: z.string().min(1).max(256).optional(),
+    horizontalSpacing: z.number().int().min(80).max(1000).optional(),
+    verticalSpacing: z.number().int().min(60).max(1000).optional(),
+    reviewScale: z
+        .number()
+        .min(FOCUS_RENDER_MIN_OUTPUT_SCALE)
+        .max(FOCUS_RENDER_MAX_OUTPUT_SCALE)
+        .optional(),
+    columns: z.number().int().min(1).max(12).optional(),
+    padding: z.number().int().min(0).max(1000).optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    const mode = value.mode ?? 'national';
+    const invalid = mode === 'national'
+        ? [
+            ['paletteId', value.paletteId],
+            ['columns', value.columns],
+        ]
+        : [
+            ['treeId', value.treeId],
+            ['horizontalSpacing', value.horizontalSpacing],
+            ['verticalSpacing', value.verticalSpacing],
+            ['reviewScale', value.reviewScale],
+        ];
+    for (const [field, fieldValue] of invalid) {
+        if (fieldValue !== undefined)
+            context.addIssue({
+                code: 'custom',
+                path: [field],
+                message: `${field} is not valid in ${mode} mode`,
+            });
+    }
+    if (mode === 'continuous' && value.padding !== undefined && value.padding < 24)
+        context.addIssue({
+            code: 'custom',
+            path: ['padding'],
+            message: 'continuous focus padding must be at least 24 pixels',
+        });
+});
+export const focusRewriteRequestSchema = z
+    .object({
+    mode: z.enum(['national', 'continuous']).optional(),
+    workspaceId: workspaceIdSchema,
+    relativePath: workspaceRelativePathSchema,
+    treeId: z.string().min(1).max(256).optional(),
+    layoutMode: z.enum(['authored', 'compact']).default('authored'),
+    plan: compactFocusPlanSchema.optional(),
+    createIfMissing: z.boolean().default(false),
+    horizontalSpacing: z.number().int().min(80).max(1000).optional(),
+    verticalSpacing: z.number().int().min(60).max(1000).optional(),
+    padding: z.number().int().min(0).max(1000).optional(),
+    reviewScale: z
+        .number()
+        .min(FOCUS_RENDER_MIN_OUTPUT_SCALE)
+        .max(FOCUS_RENDER_MAX_OUTPUT_SCALE)
+        .optional(),
+    requestKey: backgroundRequestKeySchema.optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    const mode = value.mode ?? 'national';
+    const schema = mode === 'continuous' ? continuousFocusPaletteSchema : focusTreePlanSchema;
+    if (value.plan !== undefined && !schema.safeParse(value.plan).success)
+        context.addIssue({
+            code: 'custom',
+            path: ['plan'],
+            message: `plan must be a ${mode} focus plan`,
+        });
+    if (mode === 'continuous') {
+        if (value.plan === undefined)
+            context.addIssue({
+                code: 'custom',
+                path: ['plan'],
+                message: 'plan is required in continuous mode',
+            });
+        if (value.treeId !== undefined)
+            context.addIssue({
+                code: 'custom',
+                path: ['treeId'],
+                message: 'treeId is only valid in national mode',
+            });
+        if (value.layoutMode !== 'authored')
+            context.addIssue({
+                code: 'custom',
+                path: ['layoutMode'],
+                message: 'compact layout mode is only valid in national mode',
+            });
+        for (const [field, fieldValue] of [
+            ['horizontalSpacing', value.horizontalSpacing],
+            ['verticalSpacing', value.verticalSpacing],
+            ['padding', value.padding],
+            ['reviewScale', value.reviewScale],
+        ])
+            if (fieldValue !== undefined)
+                context.addIssue({
+                    code: 'custom',
+                    path: [field],
+                    message: `${field} is only valid for national focus review renders`,
+                });
+    }
+    else {
+        if (value.plan === undefined && value.layoutMode !== 'compact')
+            context.addIssue({
+                code: 'custom',
+                path: ['plan'],
+                message: 'plan is required unless layoutMode is compact',
+            });
+        if (value.plan === undefined && value.treeId === undefined)
+            context.addIssue({
+                code: 'custom',
+                path: ['treeId'],
+                message: 'treeId is required for plan-free compact reflow',
+            });
+        if (value.plan === undefined && value.createIfMissing)
+            context.addIssue({
+                code: 'custom',
+                path: ['createIfMissing'],
+                message: 'plan-free compact reflow requires an existing focus source',
+            });
+        if (value.plan !== undefined &&
+            value.treeId !== undefined &&
+            'id' in value.plan &&
+            value.plan.id !== value.treeId)
+            context.addIssue({
+                code: 'custom',
+                path: ['treeId'],
+                message: 'treeId must match the supplied national focus plan',
+            });
+    }
+});