project-tiny-context-harness 0.2.84 → 0.6.0

package/dist/lib/superpowers-task-protected-baseline.js

@@ -1,66 +0,0 @@
-import { isHarnessPath } from "./superpowers-task-harness-drift.js";
-import { isRecord } from "./superpowers-task-state-schema.js";
-export const PROTECTED_BASELINE_PATHS = [
-    "packages/ty-context/assets/protected-harness-baseline.json",
-    ".codex/ty-context-managed/protected-harness-baseline.json",
-    "packages/ty-context/source-mappings.yaml",
-    "packages/ty-context/src/lib/superpowers-task-gates.ts",
-    "packages/ty-context/src/lib/superpowers-task-completion-output.ts",
-    "packages/ty-context/src/lib/superpowers-task-final-card.ts",
-    "packages/ty-context/src/lib/superpowers-task-validator.ts",
-    "packages/ty-context/src/lib/superpowers-task-derive.ts",
-    "packages/ty-context/src/lib/superpowers-task-evidence.ts",
-    "packages/ty-context/src/lib/superpowers-task-evidence-kernel.ts",
-    "packages/ty-context/src/lib/superpowers-task-current-evidence.ts",
-    "packages/ty-context/src/lib/superpowers-task-command-run-correlation.ts",
-    "packages/ty-context/src/lib/superpowers-task-unregistered-evidence.ts",
-    "packages/ty-context/src/lib/superpowers-task-ac010.ts",
-    "packages/ty-context/src/lib/superpowers-task-harness-drift.ts",
-    "packages/ty-context/src/lib/superpowers-task-protected-baseline.ts",
-    "packages/ty-context/src/lib/superpowers-task-state-schema.ts",
-    ".codex/ty-context-managed/skills/composite-long-task-workflow/SKILL.md",
-    ".codex/ty-context-managed/skills/composite-long-task-workflow/references/composite-long-task-workflow-protocol.md",
-    ".codex/ty-context-managed/skills/composite-long-task-workflow/assets/goal-objective.template.md",
-    ".codex/ty-context-managed/skills/composite-long-task-workflow/assets/execution-binding.template.md",
-    "packages/ty-context/assets/skills/composite-long-task-workflow/SKILL.md",
-    "packages/ty-context/assets/skills/composite-long-task-workflow/references/composite-long-task-workflow-protocol.md",
-    "packages/ty-context/assets/skills/composite-long-task-workflow/assets/goal-objective.template.md",
-    "packages/ty-context/assets/skills/composite-long-task-workflow/assets/execution-binding.template.md",
-    "tests/ty-context/composite-long-task-completion-output-gate.test.mjs",
-    "tests/ty-context/fixtures/composite-long-task/completion-output-gate/expected-outcomes.json",
-    "tests/ty-context/composite-long-task-false-completion-regression.test.mjs",
-    "tests/ty-context/fixtures/composite-long-task/false-completion-regression/manifest.json"
-];
-export function evaluateProtectedBaseline(state) {
-    const attempt = currentAttempt(state);
-    const changedFiles = [...new Set((attempt?.changed_files ?? []).map((file) => file.replace(/\\/g, "/")).filter(Boolean))];
-    const protectedChanges = changedFiles.filter(isProtectedBaselinePath);
-    const mode = attempt?.mode ?? "product_task";
-    const errors = [];
-    if (mode === "product_task" && protectedChanges.length > 0) {
-        errors.push(`protected_baseline_changed: product_task cannot change protected harness baseline paths: ${protectedChanges.join(", ")}`);
-    }
-    if (mode === "harness_task" && protectedChanges.length > 0 && !protectedBaselineReason(state)) {
-        errors.push("protected_baseline_reason_required: harness_task baseline changes must record gates.protected_baseline.reason");
-    }
-    return {
-        protected_baseline_changed: protectedChanges.length > 0,
-        product_goal_complete: errors.length === 0,
-        changed_files: protectedChanges,
-        errors
-    };
-}
-export function isProtectedBaselinePath(file) {
-    const normalized = file.replace(/\\/g, "/");
-    return PROTECTED_BASELINE_PATHS.includes(normalized) || isHarnessPath(normalized);
-}
-function protectedBaselineReason(state) {
-    const baseline = state.gates?.protected_baseline;
-    return isRecord(baseline) && typeof baseline.reason === "string" && baseline.reason.trim().length > 0;
-}
-function currentAttempt(state) {
-    if (!state.current_attempt_id) {
-        return undefined;
-    }
-    return (state.attempts ?? []).find((item) => item.task_attempt_id === state.current_attempt_id);
-}

package/dist/lib/superpowers-task-source-compile.d.ts

@@ -1,5 +0,0 @@
-import { type SuperpowersAcceptanceCriterion, type SuperpowersPlanItem, type SuperpowersProductArchitectureScope } from "./superpowers-task-state-schema.js";
-export declare const DEFAULT_LAYERS: string[];
-export declare function parseProductArchitectureScope(content: string, sourceFile: string): SuperpowersProductArchitectureScope;
-export declare function parsePlanItems(content: string, sourceFile: string): Record<string, SuperpowersPlanItem>;
-export declare function parseAcceptanceCriteria(content: string, sourceFile: string): Record<string, SuperpowersAcceptanceCriterion>;

package/dist/lib/superpowers-task-source-compile.js

@@ -1,226 +0,0 @@
-import { MACHINE_VERIFIABLE_PROOF_LAYERS, proofLayerName } from "./superpowers-task-assertions.js";
-import { compileReportSuffix, missingCategory, throwCompileErrors } from "./superpowers-task-compile-diagnostics.js";
-import { ACCEPTANCE_FIELDS, ACCEPTANCE_SCOPES, fieldSet, isSelectedScopeFitSlice, normalizeProofLayerName, PLAN_DELIVERY_SCOPES, PLAN_FIELDS, PRODUCT_DELIVERY_SCOPES, PRODUCT_FIELDS, SCOPE_FIT_DECISIONS } from "./superpowers-task-fields.js";
-import { fieldArray, fieldBoolean, fieldLine, fieldText, parseDocumentFields, parseHeadingDefinitions } from "./superpowers-task-source-parser.js";
-export const DEFAULT_LAYERS = ["code", "test"];
-const PRODUCT_FIELD_SET = fieldSet(PRODUCT_FIELDS);
-const PLAN_FIELD_SET = fieldSet(PLAN_FIELDS);
-const ACCEPTANCE_FIELD_SET = fieldSet(ACCEPTANCE_FIELDS);
-export function parseProductArchitectureScope(content, sourceFile) {
-    const fields = parseDocumentFields(content, sourceFile, PRODUCT_FIELD_SET);
-    const errors = [];
-    const selectedScopeFitSlice = requireText(errors, "Product / Architecture Source", "selected_scope_fit_slice", fields, sourceFile, 1);
-    if (selectedScopeFitSlice && !isSelectedScopeFitSlice(selectedScopeFitSlice)) {
-        errors.push(`Product / Architecture Source invalid selected_scope_fit_slice: ${selectedScopeFitSlice} at ${sourceFile}:${fieldLine(fields, "selected_scope_fit_slice") ?? 1}; allowed: none or SFC-###${compileReportSuffix("blocking_unparseable_object", sourceFile, fieldLine(fields, "selected_scope_fit_slice") ?? 1, "selected_scope_fit_slice", "value must be none or an SFC-### id", "fix selected_scope_fit_slice and rerun compile")}`);
-    }
-    const scope = {
-        delivery_scope: requireEnum(errors, "Product / Architecture Source", "delivery_scope", fields, PRODUCT_DELIVERY_SCOPES, sourceFile, 1),
-        full_population_required: requireBoolean(errors, "Product / Architecture Source", "full_population_required", fields, sourceFile, 1),
-        representative_samples_validate: requireArray(errors, "Product / Architecture Source", "representative_samples_validate", fields, sourceFile, 1),
-        representative_samples_do_not_validate: requireArray(errors, "Product / Architecture Source", "representative_samples_do_not_validate", fields, sourceFile, 1),
-        out_of_scope_backlog: requireArray(errors, "Product / Architecture Source", "out_of_scope_backlog", fields, sourceFile, 1),
-        scope_fit_decision: requireEnum(errors, "Product / Architecture Source", "scope_fit_decision", fields, SCOPE_FIT_DECISIONS, sourceFile, 1),
-        selected_scope_fit_slice: selectedScopeFitSlice,
-        owner_boundary: requireText(errors, "Product / Architecture Source", "owner_boundary", fields, sourceFile, 1),
-        primary_capability_path: requireText(errors, "Product / Architecture Source", "primary_capability_path", fields, sourceFile, 1),
-        non_completing_outcomes: requireArray(errors, "Product / Architecture Source", "non_completing_outcomes", fields, sourceFile, 1),
-        assertion_policy: requireText(errors, "Product / Architecture Source", "assertion_policy", fields, sourceFile, 1),
-        source_authority: requireText(errors, "Product / Architecture Source", "source_authority", fields, sourceFile, 1),
-        product_goal: requireText(errors, "Product / Architecture Source", "product_goal", fields, sourceFile, 1),
-        surface_ia_lock: optionalText(fields, "surface_ia_lock"),
-        decision_lock: optionalText(fields, "decision_lock"),
-        context_delta: optionalText(fields, "context_delta"),
-        source_to_context_coverage: optionalText(fields, "source_to_context_coverage"),
-        acceptance_semantics: optionalText(fields, "acceptance_semantics"),
-        impact: optionalText(fields, "impact")
-    };
-    throwCompileErrors(errors);
-    return scope;
-}
-export function parsePlanItems(content, sourceFile) {
-    const items = {};
-    const errors = [];
-    for (const definition of parseHeadingDefinitions(content, { kind: "PI", sourceFile, allowedFields: PLAN_FIELD_SET })) {
-        const fields = definition.fields;
-        items[definition.id] = {
-            requirement: definition.title,
-            source_file: definition.source_file,
-            source_start_line: definition.source_start_line,
-            source_end_line: definition.source_end_line,
-            delivery_scope: requireEnum(errors, definition.id, "delivery_scope", fields, PLAN_DELIVERY_SCOPES, sourceFile, definition.source_start_line),
-            capability_target: requireText(errors, definition.id, "capability_target", fields, sourceFile, definition.source_start_line),
-            representative_samples: requireArray(errors, definition.id, "representative_samples", fields, sourceFile, definition.source_start_line),
-            full_population_boundary: requireText(errors, definition.id, "full_population_boundary", fields, sourceFile, definition.source_start_line),
-            non_required_population: requireArray(errors, definition.id, "non_required_population", fields, sourceFile, definition.source_start_line),
-            owner_boundary: requireText(errors, definition.id, "owner_boundary", fields, sourceFile, definition.source_start_line),
-            primary_capability_path: requireText(errors, definition.id, "primary_capability_path", fields, sourceFile, definition.source_start_line),
-            trigger_contract: requireText(errors, definition.id, "trigger_contract", fields, sourceFile, definition.source_start_line),
-            state_transition_contract: requireText(errors, definition.id, "state_transition_contract", fields, sourceFile, definition.source_start_line),
-            observable_result_contract: requireText(errors, definition.id, "observable_result_contract", fields, sourceFile, definition.source_start_line),
-            assertion_support: requireText(errors, definition.id, "assertion_support", fields, sourceFile, definition.source_start_line),
-            required_assertion_commands: requireArray(errors, definition.id, "required_assertion_commands", fields, sourceFile, definition.source_start_line),
-            invalid_implementation_shortcuts: requireArray(errors, definition.id, "invalid_implementation_shortcuts", fields, sourceFile, definition.source_start_line),
-            owner_surfaces: optionalArray(fields, "owner_surfaces"),
-            forbidden_surfaces: optionalArray(fields, "forbidden_surfaces"),
-            implementation_paths: requireArray(errors, definition.id, "implementation_paths", fields, sourceFile, definition.source_start_line),
-            required_tests: optionalArray(fields, "required_tests"),
-            proof_layer_ids: optionalArray(fields, "proof_layer_ids").map(normalizeLayerId),
-            requirement_ref: optionalText(fields, "requirement_ref"),
-            decision_id: optionalText(fields, "decision_id"),
-            api_schema_changes: optionalText(fields, "api_schema_changes"),
-            state_machine: optionalText(fields, "state_machine"),
-            data_flow: optionalText(fields, "data_flow"),
-            worker_runtime_behavior: optionalText(fields, "worker_runtime_behavior"),
-            ui_ia_changes: optionalText(fields, "ui_ia_changes"),
-            migration_plan: optionalText(fields, "migration_plan"),
-            evidence_artifacts: optionalArray(fields, "evidence_artifacts"),
-            non_completing_shortcuts: optionalArray(fields, "non_completing_shortcuts"),
-            substitution_policy: optionalArray(fields, "substitution_policy"),
-            drift_severity: optionalText(fields, "drift_severity"),
-            partial_conditions: optionalArray(fields, "partial_conditions"),
-            blockers: optionalArray(fields, "blockers"),
-            explicit_no_test_scope: fieldBoolean(fields, "explicit_no_test_scope") === true,
-            context_fact_refs: optionalArray(fields, "context_fact_refs"),
-            status: "not_started",
-            related_acs: optionalArray(fields, "related_acs").map((item) => item.toUpperCase()),
-            required_proof_layers: []
-        };
-    }
-    throwCompileErrors(errors);
-    return items;
-}
-export function parseAcceptanceCriteria(content, sourceFile) {
-    const items = {};
-    const errors = [];
-    for (const definition of parseHeadingDefinitions(content, { kind: "AC", sourceFile, allowedFields: ACCEPTANCE_FIELD_SET })) {
-        const fields = definition.fields;
-        const layers = requireArray(errors, definition.id, "required_proof_layers", fields, sourceFile, definition.source_start_line).map(normalizeLayer).filter(Boolean);
-        const requiredProofLayers = layers.length > 0 ? layers : DEFAULT_LAYERS;
-        items[definition.id] = {
-            scope: definition.title,
-            source_file: definition.source_file,
-            source_start_line: definition.source_start_line,
-            source_end_line: definition.source_end_line,
-            acceptance_scope: requireEnum(errors, definition.id, "acceptance_scope", fields, ACCEPTANCE_SCOPES, sourceFile, definition.source_start_line),
-            ac_validates: requireArray(errors, definition.id, "ac_validates", fields, sourceFile, definition.source_start_line),
-            ac_does_not_validate: requireArray(errors, definition.id, "ac_does_not_validate", fields, sourceFile, definition.source_start_line),
-            sample_boundary: requireText(errors, definition.id, "sample_boundary", fields, sourceFile, definition.source_start_line),
-            full_population_required: requireBoolean(errors, definition.id, "full_population_required", fields, sourceFile, definition.source_start_line),
-            related_plan_items: requireArray(errors, definition.id, "related_plan_items", fields, sourceFile, definition.source_start_line).map((item) => item.toUpperCase()),
-            required_proof_layers: requiredProofLayers,
-            assertion_requirements: assertionRequirements(fields, requiredProofLayers),
-            assertion_command: requireText(errors, definition.id, "assertion_command", fields, sourceFile, definition.source_start_line),
-            assertion_artifacts: requireArray(errors, definition.id, "assertion_artifacts", fields, sourceFile, definition.source_start_line),
-            positive_assertions: requireArray(errors, definition.id, "positive_assertions", fields, sourceFile, definition.source_start_line),
-            negative_assertions: requireArray(errors, definition.id, "negative_assertions", fields, sourceFile, definition.source_start_line),
-            machine_blocking: requireBoolean(errors, definition.id, "machine_blocking", fields, sourceFile, definition.source_start_line),
-            invalid_completion_signals: requireArray(errors, definition.id, "invalid_completion_signals", fields, sourceFile, definition.source_start_line),
-            assertion_result_required: requireBoolean(errors, definition.id, "assertion_result_required", fields, sourceFile, definition.source_start_line),
-            ac_type: optionalText(fields, "ac_type"),
-            proof_chain: optionalArray(fields, "proof_chain").map(normalizeLayerId),
-            required_test_ids: optionalArray(fields, "required_test_ids"),
-            fail_conditions: optionalArray(fields, "fail_conditions"),
-            invalid_evidence: optionalArray(fields, "invalid_evidence"),
-            substitution_policy: optionalArray(fields, "substitution_policy"),
-            missing_layer_downgrade: optionalText(fields, "missing_layer_downgrade"),
-            auditor_expectation: optionalText(fields, "auditor_expectation"),
-            out_of_scope_na_approval_source: optionalText(fields, "out_of_scope_na_approval_source"),
-            hard_blockers: optionalArray(fields, "hard_blockers"),
-            validates_explanation: optionalText(fields, "validates_explanation"),
-            does_not_validate_explanation: optionalText(fields, "does_not_validate_explanation"),
-            final_evidence_expected: optionalArray(fields, "final_evidence_expected"),
-            verification_method: optionalArray(fields, "verification_method"),
-            test_cases: optionalArray(fields, "test_cases"),
-            explicit_no_test_scope: fieldBoolean(fields, "explicit_no_test_scope") === true,
-            status: "not_run"
-        };
-    }
-    throwCompileErrors(errors);
-    return items;
-}
-function normalizeLayer(value) {
-    return normalizeProofLayerName(value);
-}
-function normalizeLayerId(value) {
-    const trimmed = value.trim();
-    if (!trimmed.includes(".")) {
-        return normalizeLayer(trimmed);
-    }
-    const acId = trimmed.slice(0, trimmed.lastIndexOf(".")).toUpperCase();
-    const layer = trimmed.slice(trimmed.lastIndexOf(".") + 1);
-    return `${acId}.${normalizeLayer(layer)}`;
-}
-function assertionRequirements(fields, layers) {
-    const requiredTestIds = optionalArray(fields, "required_test_ids");
-    const positiveAssertions = unique(optionalArray(fields, "positive_assertions"));
-    const negativeAssertions = unique(optionalArray(fields, "negative_assertions"));
-    const assertionCommand = fieldText(fields, "assertion_command");
-    const assertionArtifacts = optionalArray(fields, "assertion_artifacts");
-    const machineBlocking = fieldBoolean(fields, "machine_blocking");
-    const assertionResultRequired = fieldBoolean(fields, "assertion_result_required");
-    const invalidCompletionSignals = optionalArray(fields, "invalid_completion_signals");
-    return layers.map((layer) => {
-        const normalized = proofLayerName(normalizeLayer(layer));
-        return {
-            proof_layer: normalized,
-            required: true,
-            machine_blocking: machineBlocking ?? MACHINE_VERIFIABLE_PROOF_LAYERS.has(normalized),
-            assertion_result_required: assertionResultRequired ?? MACHINE_VERIFIABLE_PROOF_LAYERS.has(normalized),
-            assertion_command: assertionCommand,
-            assertion_artifacts: assertionArtifacts,
-            invalid_completion_signals: invalidCompletionSignals,
-            required_test_ids: requiredTestIds,
-            positive_assertions: positiveAssertions,
-            negative_assertions: negativeAssertions
-        };
-    });
-}
-function requireEnum(errors, label, name, fields, allowed, sourceFile, fallbackLine) {
-    const value = fieldText(fields, name);
-    const line = fieldLine(fields, name) ?? fallbackLine;
-    if (!value) {
-        errors.push(`${label} missing ${name} at ${sourceFile}:${line}${compileReportSuffix(missingCategory(label), sourceFile, line, name, "field is required", "add the required field and rerun compile")}`);
-        return "";
-    }
-    if (!allowed.has(value)) {
-        errors.push(`${label} invalid ${name}: ${value} at ${sourceFile}:${line}; allowed: ${[...allowed].join(", ")}${compileReportSuffix("blocking_unparseable_object", sourceFile, line, name, `value must be one of ${[...allowed].join(", ")}`, "fix the field value and rerun compile")}`);
-    }
-    return value;
-}
-function requireText(errors, label, name, fields, sourceFile, fallbackLine) {
-    const value = fieldText(fields, name);
-    const line = fieldLine(fields, name) ?? fallbackLine;
-    if (!value) {
-        errors.push(`${label} missing ${name} at ${sourceFile}:${line}${compileReportSuffix(missingCategory(label), sourceFile, line, name, "field is required", "add non-empty text and rerun compile")}`);
-    }
-    return value;
-}
-function requireArray(errors, label, name, fields, sourceFile, fallbackLine) {
-    const line = fieldLine(fields, name) ?? fallbackLine;
-    if (!fields[name]) {
-        errors.push(`${label} missing ${name} at ${sourceFile}:${line}${compileReportSuffix(missingCategory(label), sourceFile, line, name, "field is required", "add the list field and rerun compile")}`);
-        return [];
-    }
-    return fieldArray(fields, name);
-}
-function requireBoolean(errors, label, name, fields, sourceFile, fallbackLine) {
-    const line = fieldLine(fields, name) ?? fallbackLine;
-    if (!fields[name]) {
-        errors.push(`${label} missing ${name} at ${sourceFile}:${line}${compileReportSuffix(missingCategory(label), sourceFile, line, name, "field is required", "add true or false and rerun compile")}`);
-        return null;
-    }
-    const value = fieldBoolean(fields, name);
-    if (value === null) {
-        errors.push(`${label} invalid ${name}: ${fieldText(fields, name)} at ${sourceFile}:${line}; must be true or false${compileReportSuffix("blocking_unparseable_object", sourceFile, line, name, "value must be true or false", "fix the boolean and rerun compile")}`);
-    }
-    return value;
-}
-function optionalArray(fields, name) {
-    return fields[name] ? fieldArray(fields, name) : [];
-}
-function optionalText(fields, name) {
-    return fields[name] ? fieldText(fields, name) : "";
-}
-function unique(values) {
-    return [...new Set(values.filter(Boolean))];
-}

package/dist/lib/superpowers-task-source-parser.d.ts

@@ -1,23 +0,0 @@
-export interface ParsedField {
-    value: string | string[];
-    line: number;
-}
-export interface ParsedDefinition {
-    id: string;
-    title: string;
-    fields: Record<string, ParsedField>;
-    source_file: string;
-    source_start_line: number;
-    source_end_line: number;
-}
-export interface DefinitionParseOptions {
-    kind: "PI" | "AC";
-    sourceFile: string;
-    allowedFields: Set<string>;
-}
-export declare function parseHeadingDefinitions(content: string, options: DefinitionParseOptions): ParsedDefinition[];
-export declare function parseDocumentFields(content: string, sourceFile: string, allowedFields: Set<string>): Record<string, ParsedField>;
-export declare function fieldText(fields: Record<string, ParsedField>, name: string): string;
-export declare function fieldArray(fields: Record<string, ParsedField>, name: string): string[];
-export declare function fieldBoolean(fields: Record<string, ParsedField>, name: string): boolean | null;
-export declare function fieldLine(fields: Record<string, ParsedField>, name: string): number | undefined;

package/dist/lib/superpowers-task-source-parser.js

@@ -1,218 +0,0 @@
-import { compileError, throwCompileErrors } from "./superpowers-task-compile-diagnostics.js";
-export function parseHeadingDefinitions(content, options) {
-    const lines = splitLines(content);
-    const errors = [];
-    rejectListStyleDefinitions(lines, options, errors);
-    const headings = findDefinitionHeadings(lines, options.kind);
-    const seen = new Map();
-    const definitions = [];
-    for (const heading of headings) {
-        const firstLine = seen.get(heading.id);
-        if (firstLine !== undefined) {
-            errors.push(compileError(`${heading.id} duplicate definition at ${options.sourceFile}:${firstLine} and ${options.sourceFile}:${heading.line}`, "blocking_unparseable_object", options.sourceFile, heading.line, heading.id, "duplicate object ids make PI/AC graph references ambiguous", "keep exactly one heading definition for this id"));
-            continue;
-        }
-        seen.set(heading.id, heading.line);
-        const sourceEndLine = sectionEndLine(lines, heading.index, heading.level);
-        const section = lines.slice(heading.index, sourceEndLine);
-        definitions.push({
-            id: heading.id,
-            title: heading.title,
-            fields: parseFields(section, options.sourceFile, heading.line, options.allowedFields, errors),
-            source_file: options.sourceFile,
-            source_start_line: heading.line,
-            source_end_line: sourceEndLine
-        });
-    }
-    if (definitions.length === 0) {
-        errors.push(compileError(`${options.sourceFile} must define ${options.kind} items with Markdown headings like "## ${options.kind}-001: ..."`, options.kind === "PI" ? "blocking_missing_plan" : "blocking_missing_checklist", options.sourceFile, 1, `${options.kind}_heading`, "the source cannot compile without at least one object heading", `add headings like ## ${options.kind}-001: ...`));
-    }
-    throwCompileErrors(errors);
-    return definitions;
-}
-export function parseDocumentFields(content, sourceFile, allowedFields) {
-    const errors = [];
-    const fields = parseFields(splitLines(content), sourceFile, 1, allowedFields, errors);
-    throwCompileErrors(errors);
-    return fields;
-}
-export function fieldText(fields, name) {
-    const field = fields[name];
-    if (!field) {
-        return "";
-    }
-    return Array.isArray(field.value) ? field.value.join("\n").trim() : field.value.trim();
-}
-export function fieldArray(fields, name) {
-    const field = fields[name];
-    if (!field) {
-        return [];
-    }
-    if (Array.isArray(field.value)) {
-        return field.value.flatMap(splitScalarArray).filter(Boolean);
-    }
-    return splitScalarArray(field.value);
-}
-export function fieldBoolean(fields, name) {
-    const value = fieldText(fields, name).toLowerCase();
-    if (value === "true") {
-        return true;
-    }
-    if (value === "false") {
-        return false;
-    }
-    return null;
-}
-export function fieldLine(fields, name) {
-    return fields[name]?.line;
-}
-function parseFields(lines, sourceFile, startLine, allowedFields, errors) {
-    const fields = {};
-    for (let index = 0; index < lines.length; index++) {
-        const line = lines[index];
-        const lineNumber = startLine + index;
-        const heading = /^(#{1,6})\s+(.+?)\s*$/.exec(line);
-        if (heading && allowedFields.has(heading[2].trim())) {
-            errors.push(compileError(`${sourceFile}:${lineNumber} field headings are not supported; use "${heading[2].trim()}: ..."`, "blocking_unparseable_object", sourceFile, lineNumber, heading[2].trim(), "field heading syntax is ambiguous in compiled source", "use key: value fields"));
-            continue;
-        }
-        if (/^\s*\|/.test(line) && containsKnownField(line, allowedFields)) {
-            errors.push(compileError(`${sourceFile}:${lineNumber} table fields are not supported; use key: value fields`, "blocking_unparseable_object", sourceFile, lineNumber, "table_field", "table fields cannot be parsed into canonical state safely", "use key: value fields"));
-            continue;
-        }
-        const match = /^([a-z][a-z0-9_]*)\s*:\s*(.*)$/.exec(line);
-        if (!match) {
-            continue;
-        }
-        const name = match[1];
-        if (!allowedFields.has(name)) {
-            errors.push(compileError(`${sourceFile}:${lineNumber} unknown field ${name}`, "blocking_unparseable_object", sourceFile, lineNumber, name, "unknown fields may hide required source semantics", "rename the field to a supported canonical key"));
-            continue;
-        }
-        if (fields[name]) {
-            errors.push(compileError(`${sourceFile}:${lineNumber} duplicate field ${name}`, "blocking_unparseable_object", sourceFile, lineNumber, name, "duplicate fields make canonical source values ambiguous", "keep one field value"));
-            continue;
-        }
-        const parsed = parseFieldValue(lines, index, match[2], sourceFile, lineNumber, errors);
-        fields[name] = { value: parsed.value, line: lineNumber };
-        index = parsed.endIndex;
-    }
-    return fields;
-}
-function parseFieldValue(lines, index, rest, sourceFile, lineNumber, errors) {
-    const trimmed = rest.trim();
-    if (trimmed === "|") {
-        const block = [];
-        let cursor = index + 1;
-        for (; cursor < lines.length; cursor++) {
-            const next = lines[cursor];
-            if (next.trim() && isTopLevelFieldOrHeading(next)) {
-                break;
-            }
-            block.push(next.replace(/^\s{0,2}/, ""));
-        }
-        if (block.length === 0) {
-            errors.push(compileError(`${sourceFile}:${lineNumber} block field must include indented text`, "blocking_unparseable_object", sourceFile, lineNumber, "block_field", "empty block field cannot prove source intent", "add indented text or remove the field"));
-        }
-        return { value: block.join("\n").trim(), endIndex: cursor - 1 };
-    }
-    if (trimmed) {
-        return { value: cleanValue(trimmed), endIndex: index };
-    }
-    const values = [];
-    let cursor = index + 1;
-    for (; cursor < lines.length; cursor++) {
-        const next = lines[cursor];
-        if (!next.trim()) {
-            continue;
-        }
-        if (isTopLevelFieldOrHeading(next)) {
-            break;
-        }
-        const listItem = /^\s*[-*+]\s+(.+?)\s*$/.exec(next);
-        if (!listItem) {
-            errors.push(compileError(`${sourceFile}:${cursor + 1} field lists must use indented "- item" entries or key: | blocks`, "blocking_unparseable_object", sourceFile, cursor + 1, "list_field", "list syntax cannot be parsed into canonical arrays", "use indented '- item' entries or key: | blocks"));
-            continue;
-        }
-        values.push(cleanValue(listItem[1]));
-    }
-    return { value: values, endIndex: cursor - 1 };
-}
-function isTopLevelFieldOrHeading(line) {
-    if (/^(#{1,6})\s+/.test(line)) {
-        return true;
-    }
-    return /^([a-z][a-z0-9_]*)\s*:/.test(line);
-}
-function rejectListStyleDefinitions(lines, options, errors) {
-    const idPattern = options.kind === "PI" ? "PI" : "AC";
-    const listPattern = new RegExp(`^\\s*[-*+]\\s+(${idPattern}-\\d{3,})\\b\\s*[:.-]?`, "i");
-    for (let index = 0; index < lines.length; index++) {
-        const match = listPattern.exec(lines[index]);
-        if (!match) {
-            continue;
-        }
-        const block = listItemBlock(lines, index);
-        if (!block.some((line) => containsKnownField(line, options.allowedFields))) {
-            continue;
-        }
-        const id = match[1].toUpperCase();
-        errors.push(compileError(`${id} list-style definition is not allowed at ${options.sourceFile}:${index + 1}; use "## ${id}: ..."`, "blocking_unparseable_object", options.sourceFile, index + 1, id, "list-style object definitions are not canonical PI/AC headings", `use "## ${id}: ..."`));
-    }
-}
-function listItemBlock(lines, start) {
-    const block = [lines[start]];
-    for (let index = start + 1; index < lines.length; index++) {
-        const line = lines[index];
-        if (line.trim() && !/^\s/.test(line)) {
-            break;
-        }
-        block.push(line);
-    }
-    return block;
-}
-function findDefinitionHeadings(lines, kind) {
-    const pattern = new RegExp(`^(#{1,6})\\s+(${kind}-\\d{3,})\\b(?:\\s*[:.-]\\s*|\\s+)?(.*?)\\s*$`, "i");
-    return lines.flatMap((line, index) => {
-        const match = pattern.exec(line);
-        if (!match) {
-            return [];
-        }
-        return [{
-                id: match[2].toUpperCase(),
-                level: match[1].length,
-                title: cleanValue(match[3]) || match[2].toUpperCase(),
-                index,
-                line: index + 1
-            }];
-    });
-}
-function sectionEndLine(lines, headingIndex, headingLevel) {
-    for (let index = headingIndex + 1; index < lines.length; index++) {
-        const match = /^(#{1,6})\s+/.exec(lines[index]);
-        if (match && match[1].length <= headingLevel) {
-            return index;
-        }
-    }
-    return lines.length;
-}
-function containsKnownField(line, allowedFields) {
-    for (const field of allowedFields) {
-        if (new RegExp(`\\b${field}\\b\\s*:`, "i").test(line) || new RegExp(`\\b${field}\\b`, "i").test(line)) {
-            return true;
-        }
-    }
-    return false;
-}
-function splitScalarArray(value) {
-    return value
-        .split(/[,;\n]/)
-        .map((item) => cleanValue(item))
-        .filter(Boolean);
-}
-function splitLines(content) {
-    return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
-}
-function cleanValue(value) {
-    return value.replace(/^[-#*\s]+/, "").trim();
-}