omc-core 0.4.36 → 0.4.37

package/dist/ticket20-test-data-rule.js

@@ -1,780 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import { canonicalCloudPivotBaselineFingerprint, canonicalCloudPivotEnvironmentFingerprint } from "./cloudpivot-fingerprints.js";
-import { canonicalFormalDiscoveryFingerprint } from "./formal-capability-discovery.js";
-import { assertFamilyControlOptions, CLOUDPIVOT_8_6_26_SERIALIZED_DATA_RULE_CREATE, decodeRequiredDataRuleRow, decodeDraftControl, CLOUDPIVOT_8_6_26_SERIALIZED_FORM_DRAFT } from "./cloudpivot-low-code.js";
-import { compileNativeOperations, runNativeConfigurationPackage } from "./cloudpivot-native-configuration.js";
-import { buildKnowledgePack } from "./knowledge-pack-builder.js";
-import { KnowledgePackRuntime } from "./knowledge-pack-runtime.js";
-import { createDeliveryPlanApproval, deliveryPlanApprovalHash, proposeDeliveryPlan } from "./two-stage-change-package.js";
-import { validateConfigurationIntent } from "./configuration-intent.js";
-import { SENSITIVE_SECRET_VALUE } from "./delivery-graph.js";
-import { appendApprovalHumanBlock } from "./approval-frame-readability.js";
-import { isTicket08TargetSchema } from "./ticket08-test-model-mutation.js";
-import { activeFieldFamily, fieldFamilyMemberNamesProse, fieldFamilyRuleDemoMember } from "./families/registry.js";
-import { isTicket09TargetField, TICKET09_FIELD_FAMILY } from "./ticket09-test-field-mutation.js";
-import { TICKET11_FORM_DRAFT_ROUTE, decodeTicket11DraftControlPresence } from "./ticket11-test-form-draft.js";
-/**
- * Ticket 20 (field-type ladder issue 02a — the designer-native rule surface)
- * promotes exactly one independently bounded CloudPivot `test` data-rule
- * mutation: the bizdatarule row that makes the run's own published rule-demo
- * fixture field REQUIRED through the surface the designer itself authors —
- * dataRuleType 4 (DataRuleType.OTHER_RULE 必填规则) with the unconditional
- * options {"requiredFormula":"true","functionType:"true"} bound through
- * propertyCodes. The composite chain runs the executable Ticket 08/09/10/11
- * capabilities first; the data-rule package consumes the completed,
- * behavior-validated form-draft execution report plus fresh authoritative
- * readbacks (published fields present; the draft-configured form carrying
- * every registered selector control with the amended options — visible plus
- * the always-readonly boolean on STAFF_SELECTOR, NO condition strings
- * anywhere; no dataRuleType 4 row bound to the field and no dataRuleType 5
- * rows at all). The package is independently immutable and independently
- * dual-approved. No evidence is inferred from the prior rungs; form publish,
- * app publish, Environment release, production, staging, tenant
- * administration, Redis, restart, deployment, and runtime CRUD stay
- * rejected, and conditional rules (dataRuleType 5, display 3) are never
- * authored by this capability.
- *
- * Authoritative 8.6.26 contract (type-matrix §9 + the decompiled engine +
- * the platform's own writer):
- * - the designer's AUTHORING surface for required/readonly/display
- *   conditions is the bizdatarule row set on the schema, NOT the control
- *   options keys: on panel load resetConditionRules clears
- *   options.displayFormula/requiredFormula/readonlyCondition strings, then
- *   writeRuleToControls hydrates them from the rule lists. A hand-written
- *   options.requiredFormula is therefore wiped on load — the grey/
- *   uneditable required and the conditional-readonly-without-condition
- *   seen in the numeric-logical walkthrough (and the earlier "re-set
- *   required does not persist" mystery on TEXT fixtures);
- * - CRUD (BizDataRuleController.java:86-427, /api/app/bizdatarule → wire
- *   /api/api/app/bizdatarule): GET /list?schemaCode&dataRuleType returns
- *   the rows with `options` as a serialized JSON string (parseFormula
- *   rewrites the expression member for the row's rule family); POST
- *   /create @RequireAdmin validates schemaCode + dataRuleType non-null,
- *   runs checkDataRuleFormat, then addBizDataRule; POST|PUT /update
- *   @RequireAdmin requires id; POST|DELETE /delete?id @RequireAdmin;
- * - the platform's own writer (admin dist chunk 19407, rule modal) sends
- *   exactly the four-member create shape {schemaCode, propertyCodes,
- *   dataRuleType, options} with options built as
- *   JSON.stringify({requiredFormula:<expr>, functionType:"true"}) for the
- *   required family, and blocks empty conditions client-side ("this
- *   condition is empty!") — this capability's gates reject them with the
- *   same parity;
- * - cleanup: rule rows are schema-scoped design-time state — they die with
- *   the separately approved staged cleanup (Ticket 10 published-field
- *   cleanup, then the Ticket 08 model physical delete cascade). Absence is
- *   confirmed by the authoritative bizdatarule/list readback decoding zero
- *   rows for the fixture schema. If a live run shows surviving rows, the
- *   pinned /delete?id contract is the explicit pre-cascade fallback and
- *   the outcome stops, retains, and reports — never a silent replay.
- */
-export const TICKET20_DATA_RULE_ROUTE = "ticket20-test-data-rule";
-export const TICKET20_DATA_RULE_CAPABILITY_ID = "cloudpivot.test.data-rule-8.6.26";
-export const TICKET20_RULE_CLEANUP_CAPABILITY_ID = "cloudpivot.test.data-rule-cascade-absence-8.6.26";
-export const TICKET20_DATA_RULE_KNOWLEDGE_PACK_ID = "cloudpivot-8.6-ticket20-test-data-rule";
-export const TICKET20_TEST_ENVIRONMENT_NAME = "test";
-export const TICKET20_TEST_APPLICATION_CODE = "test";
-export const TICKET20_REFERENCE_EVIDENCE_VERSION = "8.6.26";
-export const TICKET20_DATA_RULE_ENDPOINT = "/api/api/app/bizdatarule/create";
-export const TICKET20_RULE_READBACK_ENDPOINT = "/api/api/app/bizdatarule/list";
-export const TICKET20_RULE_DELETE_ENDPOINT = "/api/api/app/bizdatarule/delete";
-export const TICKET20_REQUIRED_DATA_RULE_TYPE = 4;
-export const TICKET20_READONLY_CONDITION_DATA_RULE_TYPE = 5;
-export const TICKET20_PROHIBITED_MUTATION_TERMS = Object.freeze([
-    "app-publish", "form-publish", "bizsheet/publish", "bizsheet/update", "deploy", "restart", "release", "redis", "tenant-admin", "runtime-crud",
-    "model:", "view", "folder-create", "folder-delete", "bizproperty/create", "bizproperty/publish", "bizdatarule/update", "bizdatarule/delete",
-]);
-const TICKET20_UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-const SHA256 = /^[a-f0-9]{64}$/i;
-/** The named `test` environment and its dedicated test application are hard preconditions. */
-export function assertTicket20TestDataRuleEnvironment(settings) {
-    if (settings.environmentName !== "test")
-        throw new Error("Ticket 20 data rule is restricted to the named test environment; production and staging are rejected.");
-    if (!settings.baseUrl.trim() || !/^https?:\/\/\S+$/i.test(settings.baseUrl.trim()))
-        throw new Error("Ticket 20 data rule requires an absolute configured test environment endpoint.");
-    if (settings.testApplicationCode !== "test")
-        throw new Error("Ticket 20 data rule requires the dedicated test application to be test.");
-}
-export function ticket20DeliveryId(testRunId) { return `ticket20-data-rule-${testRunId}`; }
-/** The data-rule stage's exact operation scope: the schema's TIME field's required-rule row. */
-export function ticket20DataRuleScope(targetSchemaCode, requiredFieldCode) { return `cloudpivot:rule:${targetSchemaCode}/${requiredFieldCode}`; }
-/** Design-time designer direct URL; the fixture rule state stays inspectable here without any form publish. */
-export function ticket20DesignerDirectUrl(targetSchemaCode) { return `/admin/#/apps/model/${TICKET20_TEST_APPLICATION_CODE}/${targetSchemaCode}/field-define`; }
-export function buildTicket20RuleCleanupContract(testRunId, targetSchemaCode, targetFieldCode) {
-    if (!TICKET20_UUID_V4.test(testRunId) || !isTicket08TargetSchema(targetSchemaCode) || !isTicket09TargetField(targetFieldCode))
-        throw new Error("Ticket 20 rule cleanup contract requires the exact host-owned testRunId, fixture schema, and required field code.");
-    return Object.freeze({
-        capabilityId: TICKET20_RULE_CLEANUP_CAPABILITY_ID,
-        testRunId,
-        targetSchemaCode,
-        targetFieldCode,
-        semantics: "rule-rows-are-schema-scoped-design-time-state;they-die-with-the-staged-cleanup(ticket10-published-field-cleanup-then-ticket08-model-physical-delete-cascade);if-the-live-cascade-leaves-survivors-the-pinned-delete?id-contract-is-the-explicit-pre-cascade-fallback-and-the-outcome-stops-retains-and-reports",
-        absenceReadback: { method: "GET", endpoint: TICKET20_RULE_READBACK_ENDPOINT, expected: "zero-rows-decoded-for-the-fixture-schema" },
-        ownership: "schema-and-required-field-bound-to-testRunId",
-        replayPolicy: "absent-is-no-op",
-        uncertainPolicy: "stop-retain-report-no-retry",
-    });
-}
-/** Deterministic, run-independent contract identities pinned by the Knowledge Pack promotion. */
-export function ticket20DataRuleContractHash() { return digest(ticket20DataRuleContract()); }
-export function ticket20RuleCleanupContractHash() { return digest(ticket20RuleCleanupContractTemplate()); }
-function ticket20DataRuleContract() {
-    return {
-        capabilityId: TICKET20_DATA_RULE_CAPABILITY_ID,
-        operationKind: "data-rule-create",
-        method: "POST",
-        endpoint: CLOUDPIVOT_8_6_26_SERIALIZED_DATA_RULE_CREATE.endpoint,
-        readbackEndpoint: CLOUDPIVOT_8_6_26_SERIALIZED_DATA_RULE_CREATE.readbackEndpoint,
-        preflight: CLOUDPIVOT_8_6_26_SERIALIZED_DATA_RULE_CREATE.preflight,
-        dto: "BizDataRuleModel:the-platform-writer's-exact-four-member-create-shape(schemaCode,propertyCodes,dataRuleType,options)",
-        ruleContract: { ...CLOUDPIVOT_8_6_26_SERIALIZED_DATA_RULE_CREATE.ruleContract },
-        ruleSurface: "bizdatarule-rows-are-the-designer's-authoring-surface-for-required/readonly/display;control-options-condition-strings-are-runtime-hydration-targets-the-panel-wipes-on-load",
-        emptyConditionParity: "empty-or-missing-condition-expressions-are-rejected-by-our-gates-with-designer-client-side-parity",
-        conditionalRules: "dataRuleType-5-readonly-and-3-display-rows-are-never-authored-by-this-capability",
-        cleanup: "rule-rows-die-with-the-staged-cleanup-cascade;bizdatarule/list-zero-rows-absence-confirmation;delete?id-is-the-explicit-pre-cascade-fallback",
-        scope: "schema-scoped-required-rule-row",
-        permission: "@RequireAdmin",
-        transportMode: "serialized-server-data-rule-create-8.6.26",
-        capability: CLOUDPIVOT_8_6_26_SERIALIZED_DATA_RULE_CREATE,
-        evidence: [...CLOUDPIVOT_8_6_26_SERIALIZED_DATA_RULE_CREATE.evidence],
-        requiredPermissions: ["configuration-write"],
-        prohibited: [...TICKET20_PROHIBITED_MUTATION_TERMS],
-    };
-}
-function ticket20RuleCleanupContractTemplate() {
-    return {
-        capabilityId: TICKET20_RULE_CLEANUP_CAPABILITY_ID,
-        operationKind: "data-rule-cascade-absence-confirmation",
-        semantics: "rule-rows-die-with-the-model-physical-delete-cascade;no-separate-rule-delete-in-the-standard-chain",
-        absenceReadback: `${TICKET20_RULE_READBACK_ENDPOINT}:zero-rows-decoded-for-the-fixture-schema`,
-        ownership: "schema-and-required-field-bound-to-testRunId",
-        replayPolicy: "absent-is-no-op",
-        uncertainPolicy: "stop-retain-report-no-retry",
-    };
-}
-/** Package operations must be exactly one bounded required-rule create step bound to the run's TIME field. */
-export function assertTicket20OperationsBounded(input) {
-    if (input.operations.length !== 1)
-        throw new Error("Ticket 20 packages must contain exactly one bounded operation.");
-    const operation = input.operations[0];
-    const identity = `${operation.id} ${operation.target} ${operation.path}`.toLowerCase();
-    if (TICKET20_PROHIBITED_MUTATION_TERMS.some((term) => identity.includes(term)) || !operation.id.startsWith("rule-create:"))
-        throw new Error(`Ticket 20 operation ${operation.id} is outside the bounded operation set; prohibited families (conditional rules, rule update/delete, form writes, app publish, deploy, restart, release, redis, tenant administration, runtime CRUD) remain rejected.`);
-    const expected = { id: `rule-create:${input.targetSchemaCode}/${input.targetFieldCode}`, target: `rule:${input.targetSchemaCode}/${input.targetFieldCode}`, path: TICKET20_DATA_RULE_ENDPOINT, transportMode: "serialized-server-data-rule-create-8.6.26" };
-    if (operation.id !== expected.id || operation.path !== expected.path || operation.transportMode !== expected.transportMode || operation.target !== expected.target)
-        throw new Error(`Ticket 20 operation ${operation.id} does not match the exact target binding for ${expected.target}.`);
-}
-/** Builds the signed, version-bound pack promoting exactly the single test data-rule capability. */
-export function buildTicket20DataRuleKnowledgePack(input) {
-    const compiler = { id: "src/ticket20-test-data-rule.ts:createTicket20DataRulePlanApproval", sha256: digest("omc-ticket20-compiler-v1") };
-    const decoder = { id: "src/dsh-host-plugin.ts:createCloudPivotWriteTransport", sha256: digest("omc-ticket20-decoder-v1") };
-    return buildKnowledgePack({
-        packId: TICKET20_DATA_RULE_KNOWLEDGE_PACK_ID,
-        packVersion: "1.0.0",
-        sourceVersion: TICKET20_REFERENCE_EVIDENCE_VERSION,
-        sourceArtifacts: [{ id: "cloudpivot-8.6.26-serialized-data-rule-create-capability", sha256: digest(CLOUDPIVOT_8_6_26_SERIALIZED_DATA_RULE_CREATE) }],
-        references: [
-            { id: "omc-type-matrix-section-9-designer-rule-model", sha256: digest("omc-type-matrix-section-9-designer-rule-model") },
-            { id: TICKET20_DATA_RULE_ENDPOINT, sha256: digest(TICKET20_DATA_RULE_ENDPOINT) },
-            { id: TICKET20_RULE_READBACK_ENDPOINT, sha256: digest(TICKET20_RULE_READBACK_ENDPOINT) },
-        ],
-        compilers: [compiler],
-        decoders: [decoder],
-        capabilities: [{
-                id: TICKET20_DATA_RULE_CAPABILITY_ID,
-                status: "runtime-verified",
-                promote: true,
-                compilerRef: compiler.id,
-                decoderRef: decoder.id,
-                sourceEvidence: [...CLOUDPIVOT_8_6_26_SERIALIZED_DATA_RULE_CREATE.evidence, TICKET20_DATA_RULE_ENDPOINT, TICKET20_RULE_READBACK_ENDPOINT],
-                runtimeEvidence: ["omc-type-matrix-section-9-designer-rule-model", "cloudpivot.data-rule-create.serialized-server-8.6.26"],
-                operationPromotions: [{
-                        id: "data-rule-create",
-                        status: "promoted",
-                        operationContractHash: ticket20DataRuleContractHash(),
-                        sourceRefs: [...CLOUDPIVOT_8_6_26_SERIALIZED_DATA_RULE_CREATE.evidence, TICKET20_DATA_RULE_ENDPOINT, TICKET20_RULE_READBACK_ENDPOINT],
-                        versionFamily: "8.6",
-                        referenceVersion: TICKET20_REFERENCE_EVIDENCE_VERSION,
-                        requiredEvidence: ["cleanup", "discovery", "permission", "readback", "test", "write"],
-                        evidence: ["cleanup", "discovery", "permission", "readback", "test", "write"],
-                        blockedReasons: [],
-                    }],
-            }],
-        signerKeyId: input.signerKeyId,
-        signingKey: input.signingKey,
-        createdAt: input.createdAt,
-    });
-}
-/** Loads the pack against CloudPivot 8.6.26 and pins the single executable capability and contract hash. */
-export function loadTicket20KnowledgePack(artifact, trustedKeys) {
-    const runtime = new KnowledgePackRuntime(trustedKeys);
-    const load = runtime.load(artifact, TICKET20_REFERENCE_EVIDENCE_VERSION);
-    if (!load.accepted)
-        throw new Error(`Ticket 20 Knowledge Pack is not authoritative: ${load.blockingReasons.join(", ")}.`);
-    const active = runtime.active();
-    const capabilities = active.capabilities;
-    if (capabilities.length !== 1 || capabilities[0].id !== TICKET20_DATA_RULE_CAPABILITY_ID)
-        throw new Error("Ticket 20 Knowledge Pack must promote exactly the single test data-rule capability; evidence inference from the form rungs or to any other capability (conditional rules included) is rejected.");
-    const hashes = capabilities[0].operationContractHashes;
-    if (hashes.length !== 1 || hashes[0] !== ticket20DataRuleContractHash())
-        throw new Error("Ticket 20 Knowledge Pack operation contract hash does not match the canonical data-rule contract.");
-    return { runtime, packId: active.manifest.packId, contentDigest: active.manifest.contentSha256, executableCapabilities: capabilities.map(({ id }) => id) };
-}
-export function decodeTicket20RuleListEvidence(input) {
-    const url = `${TICKET20_RULE_READBACK_ENDPOINT}?schemaCode=${encodeURIComponent(input.schemaCode)}&dataRuleType=${String(input.dataRuleType)}`;
-    const query = { schemaCode: input.schemaCode, dataRuleType: input.dataRuleType };
-    const httpStatus = input.httpStatus ?? 200;
-    const envelope = input.body;
-    if (!envelope || typeof envelope !== "object" || Array.isArray(envelope))
-        return Object.freeze({ classification: "blocked", reason: "malformed-response", query, url, httpStatus, rows: [] });
-    if (httpStatus < 200 || httpStatus >= 300)
-        return Object.freeze({ classification: "blocked", reason: "http-error", query, url, httpStatus, rows: [] });
-    if (envelope.errcode !== 0) {
-        const errcode = typeof envelope.errcode === "number" ? envelope.errcode : undefined;
-        // ONLY the schema-absence envelope (the engine's business-model-missing
-        // family, errcode 10011 — the rule rows are schema-scoped and the
-        // facade resolves the schema first) decodes as rule absence; every
-        // other non-success envelope (auth, malformed query, server fault) is
-        // BLOCKED, never a falsely-confirmed zero-rows cleanup gate.
-        if (errcode === 10011)
-            return Object.freeze({ classification: "absent", reason: "schema-rule-absence", query, url, httpStatus, ...(errcode !== undefined ? { errcode } : {}), rows: [] });
-        return Object.freeze({ classification: "blocked", reason: "malformed-response", query, url, httpStatus, ...(errcode !== undefined ? { errcode } : {}), rows: [] });
-    }
-    const data = envelope.data;
-    if (!Array.isArray(data) || !data.every((row) => row === null || typeof row === "object"))
-        return Object.freeze({ classification: "blocked", reason: "malformed-response", query, url, httpStatus, rows: [] });
-    const rows = data.filter((row) => row !== null && typeof row === "object");
-    return Object.freeze({ classification: "present", reason: "rows-decoded", query, url, httpStatus, rows });
-}
-/**
- * Host-owned composite-chain evidence capture: consumes the completed
- * form-draft handoff and proves BOTH published family fields present, BOTH
- * typed controls bound with the amended options (visible + the
- * always-readonly boolean only — NO condition strings), no required-rule row
- * bound to the field, and no conditional rules at all.
- */
-export function captureTicket20DataRuleEvidence(input) {
-    assertTicket20TestDataRuleEnvironment(input.settings);
-    if (!TICKET20_UUID_V4.test(input.testRunId))
-        throw new Error("Ticket 20 evidence capture requires the run's host-owned UUID v4 testRunId.");
-    const handoff = input.handoff;
-    const report = handoff.formDraftExecutionReport;
-    const draftEvidence = handoff.formDraftEvidence;
-    if (!handoff.formDraftPackageId || !SHA256.test(handoff.formDraftPackageHash) || !/[1-9a-f]/i.test(handoff.formDraftPackageHash) || report.route !== TICKET11_FORM_DRAFT_ROUTE || report.status !== "completed" || report.mutationExecuted !== true || report.behavior?.status !== "validated")
-        throw new Error("Ticket 20 data rule requires the completed, behavior-validated form-draft handoff; serial writes never assume state.");
-    if (report.testRunId !== input.testRunId || draftEvidence.testRunId !== input.testRunId)
-        throw new Error("Ticket 20 composite chain requires the single run testRunId across the model, field, publish, form-draft, and data-rule packages.");
-    const targetSchemaCode = draftEvidence.targetSchemaCode;
-    const targetFieldCodes = draftEvidence.targetFieldCodes;
-    // Ticket 03b: the required-rule demo target is the ACTIVE family's
-    // registered rule-demo member (position 2 for date-time: the TIME field).
-    const targetFieldCode = targetFieldCodes[activeFieldFamily().ruleDemoTargetPosition - 1];
-    const targetSheetCode = draftEvidence.targetSheetCode;
-    if (!isTicket08TargetSchema(targetSchemaCode) || !isTicket09TargetField(targetFieldCode) || report.targetSchemaCode !== targetSchemaCode || report.targetSheetCode !== targetSheetCode || report.targetFieldCodes.length !== targetFieldCodes.length || report.targetFieldCodes.some((fieldCode, index) => fieldCode !== targetFieldCodes[index]))
-        throw new Error("Ticket 20 fixture family identity diverges from the completed form-draft handoff.");
-    const modelPresence = input.modelPresence;
-    if (modelPresence.classification !== "present" || modelPresence.query.schemaCode !== targetSchemaCode)
-        throw new Error("Ticket 20 data rule requires the fixture model to be present in fresh authoritative readback.");
-    targetFieldCodes.forEach((targetCode, index) => {
-        const member = TICKET09_FIELD_FAMILY[index];
-        const publishedFieldPresence = input.publishedFieldPresence[index];
-        if (publishedFieldPresence.classification !== "present" || publishedFieldPresence.reason !== "exact-presence" || publishedFieldPresence.query.schemaCode !== targetSchemaCode || publishedFieldPresence.query.propertyCode !== targetCode || publishedFieldPresence.query.isPublish !== "true")
-            throw new Error(`Ticket 20 evidence capture requires exact authenticated published-state presence for the ${member.propertyTypeName} handoff field; rule work only ever consumes published configuration.`);
-        if (!publishedFieldPresence.field || publishedFieldPresence.field.code !== targetCode || publishedFieldPresence.field.schemaCode !== targetSchemaCode || publishedFieldPresence.field.published !== true)
-            throw new Error(`Ticket 20 evidence capture requires the ${member.propertyTypeName} field's published flag to decode from the authoritative published readback.`);
-    });
-    const formDraftState = input.formDraftState;
-    if (formDraftState.classification !== "present" || formDraftState.reason !== "exact-presence" || formDraftState.query.schemaCode !== targetSchemaCode || formDraftState.query.sheetCode !== targetSheetCode || !formDraftState.form)
-        throw new Error("Ticket 20 evidence capture requires the draft-configured default form to be present in fresh authoritative readback.");
-    if (formDraftState.form.published !== false)
-        throw new Error("Ticket 20 evidence capture requires the fixture form to stay unpublished; the data-rule rung never touches a published form.");
-    // §9 re-gate on the consumed draft state: every registered control decodes with
-    // the amended options — visible family key, the per-type pinned keys, the
-    // the always-readonly boolean on STAFF_SELECTOR, and NO condition strings
-    // anywhere (the authoring surface for conditions is the rule rows this
-    // rung creates, never the control options keys).
-    targetFieldCodes.forEach((targetCode, index) => {
-        const presence = decodeTicket11DraftControlPresence(formDraftState.form, targetCode);
-        if (!presence.decodable || presence.layoutOccurrences !== 1 || !presence.control)
-            throw new Error(`Ticket 20 evidence capture requires the ${TICKET09_FIELD_FAMILY[index].propertyTypeName} handoff field's typed control to be bound exactly once in the consumed draft state.`);
-        assertFamilyControlOptions(CLOUDPIVOT_8_6_26_SERIALIZED_FORM_DRAFT.boundControls, presence.control, CLOUDPIVOT_8_6_26_SERIALIZED_FORM_DRAFT.boundControls[index].propertyTypeName, { schemaCode: targetSchemaCode, memberFieldCodes: targetFieldCodes });
-    });
-    const requiredRulePreState = input.requiredRulePreState;
-    if (requiredRulePreState.classification !== "present" || requiredRulePreState.query.schemaCode !== targetSchemaCode || requiredRulePreState.query.dataRuleType !== TICKET20_REQUIRED_DATA_RULE_TYPE)
-        throw new Error("Ticket 20 evidence capture requires the authoritative required-rule (dataRuleType=4) list readback to decode before any write.");
-    const boundRequiredRow = requiredRulePreState.rows.find((row) => decodeRequiredDataRuleRow(row, targetSchemaCode, targetFieldCode) !== undefined);
-    if (boundRequiredRow)
-        throw new Error("Ticket 20 evidence capture requires exact required-rule absence for the handoff field; duplicate rule authoring is rejected.");
-    const readonlyRulePreState = input.readonlyRulePreState;
-    if (readonlyRulePreState.classification !== "present" || readonlyRulePreState.query.schemaCode !== targetSchemaCode || readonlyRulePreState.query.dataRuleType !== TICKET20_READONLY_CONDITION_DATA_RULE_TYPE)
-        throw new Error("Ticket 20 evidence capture requires the authoritative conditional-readonly (dataRuleType=5) list readback to decode before any write.");
-    if (readonlyRulePreState.rows.length)
-        throw new Error("Ticket 20 evidence capture found conditional-readonly rules on the fixture schema; this capability never mixes with conditional rules.");
-    const authoritativeOrigin = input.discovery.authoritativeOrigin;
-    const enterpriseId = input.discovery.enterpriseId;
-    if (!authoritativeOrigin || !enterpriseId)
-        throw new Error("Ticket 20 evidence capture requires authenticated environment fingerprint evidence.");
-    const environmentFingerprint = canonicalCloudPivotEnvironmentFingerprint({ environment: TICKET20_TEST_ENVIRONMENT_NAME, authoritativeOrigin, applicationCode: TICKET20_TEST_APPLICATION_CODE, enterpriseId });
-    if (environmentFingerprint !== draftEvidence.environmentFingerprint)
-        throw new Error("Ticket 20 data rule is outside the form-draft handoff environment fingerprint.");
-    const evidence = Object.freeze({
-        route: TICKET20_DATA_RULE_ROUTE,
-        capabilityId: TICKET20_DATA_RULE_CAPABILITY_ID,
-        environmentName: TICKET20_TEST_ENVIRONMENT_NAME,
-        applicationCode: TICKET20_TEST_APPLICATION_CODE,
-        folder: draftEvidence.folder,
-        targetSchemaCode,
-        targetSheetCode,
-        targetFieldCodes,
-        targetFieldCode,
-        testRunId: input.testRunId,
-        environmentFingerprint,
-        baselineFingerprint: canonicalCloudPivotBaselineFingerprint({ environmentFingerprint, applicationCode: TICKET20_TEST_APPLICATION_CODE, discovery: input.discovery }),
-        discoveryFingerprint: canonicalFormalDiscoveryFingerprint(input.discovery),
-        handoff,
-        modelPresence,
-        publishedFieldPresence: Object.freeze([...input.publishedFieldPresence]),
-        formDraftState,
-        requiredRulePreState,
-        readonlyRulePreState,
-        ruleContract: { dataRuleType: 4, options: CLOUDPIVOT_8_6_26_SERIALIZED_DATA_RULE_CREATE.ruleContract.options, propertyTypeName: fieldFamilyRuleDemoMember().propertyTypeName },
-        cleanupContract: buildTicket20RuleCleanupContract(input.testRunId, targetSchemaCode, targetFieldCode),
-        designerDirectUrl: ticket20DesignerDirectUrl(targetSchemaCode),
-        capturedAt: new Date((input.now ?? Date.now)()).toISOString(),
-    });
-    if ([evidence.environmentFingerprint, evidence.baselineFingerprint, evidence.discoveryFingerprint].some((value) => !SHA256.test(value)))
-        throw new Error("Ticket 20 evidence fingerprints are not canonical.");
-    if (SENSITIVE_SECRET_VALUE.test(stable(evidence)))
-        throw new Error("Ticket 20 evidence contains prohibited sensitive data.");
-    return evidence;
-}
-export const TICKET20_EVIDENCE_DEFAULT_TTL_MS = 25 * 60_000;
-export const TICKET20_EVIDENCE_MAX_TTL_MS = 30 * 60_000;
-/** Single-use, TTL-bounded evidence store; consumed exactly once by plan creation. */
-export class Ticket20EvidenceStore {
-    records = new Map();
-    now;
-    ttlMs;
-    lastNow;
-    constructor(options = {}) {
-        this.now = options.now ?? Date.now;
-        this.ttlMs = options.ttlMs ?? TICKET20_EVIDENCE_DEFAULT_TTL_MS;
-        if (!Number.isFinite(this.ttlMs) || this.ttlMs < 1 || this.ttlMs > TICKET20_EVIDENCE_MAX_TTL_MS)
-            throw new Error("Ticket 20 evidence TTL must be between 1ms and its safety maximum.");
-    }
-    capture(evidence) {
-        validateTicket20Evidence(evidence);
-        const evidenceId = `ticket20-evidence-${randomUUID()}`;
-        const expiresAt = this.readClock() + this.ttlMs;
-        const stored = Object.freeze({ ...evidence, evidenceArtifactId: evidenceId });
-        this.records.set(evidenceId, { evidence: stored, expiresAt, consumed: false });
-        return { evidenceId, expiresAt, evidence: stored };
-    }
-    consume(evidenceId) {
-        const record = this.records.get(evidenceId);
-        if (!record)
-            throw new Error("Ticket 20 evidence artifact is missing or divergent.");
-        if (record.consumed)
-            throw new Error("Ticket 20 evidence has already been consumed.");
-        if (record.expiresAt <= this.readClock())
-            throw new Error("Ticket 20 evidence is stale or expired.");
-        record.consumed = true;
-        return record.evidence;
-    }
-    resolve(evidenceId) {
-        const record = this.records.get(evidenceId);
-        if (!record || !record.consumed)
-            throw new Error("Ticket 20 evidence artifact is missing or has not been consumed by planning.");
-        if (record.expiresAt <= this.readClock())
-            throw new Error("Ticket 20 evidence artifact is stale or expired.");
-        return record.evidence;
-    }
-    readClock() {
-        const currentTime = this.now();
-        if (!Number.isFinite(currentTime))
-            throw new Error("Ticket 20 evidence clock is invalid; fail closed.");
-        if (this.lastNow !== undefined && currentTime < this.lastNow)
-            throw new Error("Ticket 20 evidence clock moved backwards; fail closed.");
-        this.lastNow = currentTime;
-        return currentTime;
-    }
-}
-/**
- * Composes the exact evidenced BizDataRuleModel create DTO — the platform
- * writer's own four-member shape: schemaCode, propertyCodes (exactly the
- * active rule-demo field code), dataRuleType 4, and the serialized options JSON
- * string {"requiredFormula":"true","functionType":"true"}. Empty-condition
- * parity is enforced by the capability gate; nothing else ships.
- */
-export function buildTicket20DataRulePayload(evidence) {
-    validateTicket20Evidence(evidence);
-    const rule = CLOUDPIVOT_8_6_26_SERIALIZED_DATA_RULE_CREATE.ruleContract;
-    return {
-        schemaCode: evidence.targetSchemaCode,
-        propertyCodes: [evidence.targetFieldCode],
-        dataRuleType: rule.dataRuleType,
-        options: rule.options,
-    };
-}
-export function buildTicket20ConfigurationIntent(evidence) {
-    validateTicket20Evidence(evidence);
-    const target = `${evidence.targetSchemaCode}/${evidence.targetFieldCode}`;
-    const ruleResourceId = `rule:${target}`;
-    return {
-        intentVersion: 1,
-        targetFamily: "8.6",
-        environmentBinding: { application: evidence.applicationCode, model: evidence.targetSchemaCode, baselineFingerprint: evidence.baselineFingerprint },
-        sourceRequirement: `Ticket 20 maintainer test (field-type ladder issue 02a, designer-native rule surface): create exactly one unconditional required rule row on the fixture schema — dataRuleType 4 with options {"requiredFormula":"true","functionType":"true"} bound to the published ${fieldFamilyRuleDemoMember().propertyTypeName} family field through propertyCodes — so the designer panel hydrates required checked AND editable from the rule row (type-matrix §9: the condition strings on control options are runtime hydration targets the panel wipes on load, never authoring keys). Never a conditional rule (dataRuleType 5/3), never a rule update/delete in the standard chain, never a form write, app publish, or Environment release — with authoritative rule-list readback, behavior validation, and the stated cascade cleanup contract.`,
-        resources: [
-            { id: ruleResourceId, kind: "dataRule", state: "update", properties: { schemaCode: evidence.targetSchemaCode, requiredFieldCode: evidence.targetFieldCode, dataRuleType: 4, options: evidence.ruleContract.options, propertyTypeName: fieldFamilyRuleDemoMember().propertyTypeName } },
-            { id: target, kind: "field", state: "existing", properties: { schemaCode: evidence.targetSchemaCode, published: true } },
-        ],
-        relationships: [{ from: ruleResourceId, to: target, kind: "bindsTo" }],
-        lifecycle: [{ resourceId: ruleResourceId, transitions: ["rule-create"], order: 1, idempotent: false, dependencyChecks: ["completed-form-draft-handoff", "required-rule-exact-absence-and-no-conditional-rules-preflight"], recoveryBoundary: ruleResourceId }],
-        behavior: [{ id: "data-rule-required-row", kind: "structure", requiredCapabilityIds: [TICKET20_DATA_RULE_CAPABILITY_ID], resourceIds: [ruleResourceId], obligations: [`the authoritative bizdatarule/list?schemaCode&dataRuleType=4 readback decodes the run's required-rule row bound to the ${fieldFamilyRuleDemoMember().propertyTypeName} field through propertyCodes`, "the row's options decode as the pinned serialized JSON {requiredFormula:\"true\", functionType:\"true\"}", "no dataRuleType 5 (conditional-readonly) rows exist on the fixture schema", "the draft selector control options decode with visible=true and the registered cardinality/multi flag, with no condition strings"] }],
-        acceptance: [{ id: "ticket20-data-rule-readback", scenario: "designer-native-required-rule-authoring", actor: "omc-maintainer-opencode", assertions: ["bizdatarule/list?schemaCode&dataRuleType=4 decodes our rule row bound to the field", "bizdatarule/list?schemaCode&dataRuleType=5 decodes zero rows", "the consumed draft control options carry no condition strings"], readbackInvariants: [`${TICKET20_RULE_READBACK_ENDPOINT}?schemaCode=<model>&dataRuleType=4 decodes the bound rule row`, `${TICKET20_RULE_READBACK_ENDPOINT}?schemaCode=<model>&dataRuleType=5 decodes zero rows`], outcome: "validated" }],
-        cleanup: [{ id: "ticket20-rule-cascade-cleanup", boundary: `ticket20:${evidence.testRunId}:data-rule-cascade-absence`, dependencyChecks: ["staged family field cleanup", "model physical delete", "rule list zero-rows readback"], resources: [`rule:${target}`] }],
-        implementationConstraints: { nativePreferred: true, backendRequired: false, prohibitedPaths: ["form.online-js", "business-rule", "integration", "backend.extension"], approvalExceptions: [] },
-        evidenceRefs: [TICKET20_DATA_RULE_CAPABILITY_ID, TICKET20_DATA_RULE_ENDPOINT, TICKET20_RULE_READBACK_ENDPOINT, ...CLOUDPIVOT_8_6_26_SERIALIZED_DATA_RULE_CREATE.evidence],
-        unresolved: [],
-    };
-}
-function ticket20DataRuleOperation(evidence) {
-    const target = `rule:${evidence.targetSchemaCode}/${evidence.targetFieldCode}`;
-    return {
-        id: `rule-create:${evidence.targetSchemaCode}/${evidence.targetFieldCode}`,
-        method: "POST",
-        path: TICKET20_DATA_RULE_ENDPOINT,
-        target,
-        payload: buildTicket20DataRulePayload(evidence),
-        expectedReadback: `${target}:created`,
-        evidence: [TICKET20_DATA_RULE_CAPABILITY_ID, ...CLOUDPIVOT_8_6_26_SERIALIZED_DATA_RULE_CREATE.evidence, TICKET20_RULE_READBACK_ENDPOINT],
-        transportMode: "serialized-server-data-rule-create-8.6.26",
-        capability: CLOUDPIVOT_8_6_26_SERIALIZED_DATA_RULE_CREATE,
-    };
-}
-/** Creates and proposes the immutable Ticket 20 Delivery Plan Approval for the single required-rule create step. */
-export function createTicket20DataRulePlanApproval(input) {
-    const evidence = validateTicket20Evidence(input.evidence);
-    assertDigest(input.knowledgePackDigest, "knowledge pack digest");
-    const operation = ticket20DataRuleOperation(evidence);
-    assertTicket20OperationsBounded({ route: TICKET20_DATA_RULE_ROUTE, operations: [operation], targetSchemaCode: evidence.targetSchemaCode, targetFieldCode: evidence.targetFieldCode });
-    const intent = buildTicket20ConfigurationIntent(evidence);
-    if (validateConfigurationIntent(intent).length)
-        throw new Error("Ticket 20 Configuration Intent is invalid; planning is blocked.");
-    const binding = {
-        deliveryId: ticket20DeliveryId(evidence.testRunId),
-        environment: TICKET20_TEST_ENVIRONMENT_NAME,
-        baselineFingerprint: evidence.baselineFingerprint,
-        environmentFingerprint: evidence.environmentFingerprint,
-        discoveryFingerprint: evidence.discoveryFingerprint,
-        ...(evidence.evidenceArtifactId ? { evidenceArtifactId: evidence.evidenceArtifactId } : {}),
-    };
-    const planHash = digest({ route: TICKET20_DATA_RULE_ROUTE, capabilityId: TICKET20_DATA_RULE_CAPABILITY_ID, target: `${evidence.targetSchemaCode}/${evidence.targetFieldCode}`, testRunId: evidence.testRunId, operation: { id: operation.id, readback: operation.expectedReadback }, requiredFieldCode: evidence.targetFieldCode, familyFieldCodes: [...evidence.targetFieldCodes], formDraftHandoff: { packageId: evidence.handoff.formDraftPackageId, packageHash: evidence.handoff.formDraftPackageHash }, folder: evidence.folder, fingerprints: { baseline: evidence.baselineFingerprint, environment: evidence.environmentFingerprint, discovery: evidence.discoveryFingerprint }, cleanupContractHash: ticket20RuleCleanupContractHash(), knowledgePackDigest: input.knowledgePackDigest, prohibited: [...TICKET20_PROHIBITED_MUTATION_TERMS] });
-    const base = createDeliveryPlanApproval({
-        binding,
-        requirementHash: digest({ target: `${evidence.targetSchemaCode}/${evidence.targetFieldCode}`, dataRule: true, dataRuleType: 4 }),
-        clarificationHash: digest("ticket20-test-data-rule"),
-        intentHash: digest(intent),
-        decisionHash: digest(TICKET20_DATA_RULE_ROUTE),
-        graphHash: digest([operation.id]),
-        riskHash: digest(TICKET20_RISKS),
-        validationPlanHash: digest("authoritative-rule-list-readback-row-decode-and-no-conditional-rows"),
-        cleanupPlanHash: ticket20RuleCleanupContractHash(),
-        allowedOperationScope: [ticket20DataRuleScope(evidence.targetSchemaCode, evidence.targetFieldCode)],
-        planHash,
-        applicationCode: TICKET20_TEST_APPLICATION_CODE,
-        folderId: evidence.folder.id,
-        folderName: evidence.folder.name,
-        targets: [`${evidence.targetSchemaCode}/${evidence.targetFieldCode}`],
-    });
-    const approval = {
-        ...base,
-        route: TICKET20_DATA_RULE_ROUTE,
-        testRunId: evidence.testRunId,
-        targetSchemaCode: evidence.targetSchemaCode,
-        targetSheetCode: evidence.targetSheetCode,
-        targetFieldCodes: evidence.targetFieldCodes,
-        targetFieldCode: evidence.targetFieldCode,
-        capabilityId: TICKET20_DATA_RULE_CAPABILITY_ID,
-        knowledgePackDigest: input.knowledgePackDigest,
-        cleanupContractHash: ticket20RuleCleanupContractHash(),
-        environmentName: TICKET20_TEST_ENVIRONMENT_NAME,
-    };
-    const proposal = { ...approval, approvalHash: deliveryPlanApprovalHash(approval) };
-    proposeDeliveryPlan(input.ledger, proposal);
-    return { approval: proposal, operation, cleanupContract: evidence.cleanupContract, intent, binding };
-}
-const TICKET20_RISKS = Object.freeze([
-    "Exactly one unconditional required rule row bound to the run's own published fixture field is in scope — dataRuleType 4 with options {requiredFormula:\"true\",functionType:\"true\"}; conditional rules (dataRuleType 5/3), rule updates, form writes, app publish, and Environment release remain rejected, and empty conditions are rejected with the designer's client-side parity.",
-    "Rule rows are schema-scoped design-time state that die with the separately approved staged cleanup (published-field cleanup, then the model physical delete cascade); rule-level absence is confirmed by the authoritative bizdatarule/list zero-rows readback, and if the live cascade leaves survivors the pinned /delete?id contract is the explicit pre-cascade fallback — the outcome stops, retains, and reports.",
-]);
-/** Compiles the immutable one-step data-rule package bound to the approved plan, pack digest, and pinned contract hash. */
-export function prepareTicket20DataRulePackage(input) {
-    const evidence = validateTicket20Evidence(input.evidence);
-    const approval = requireTicket20Approval(input.approval);
-    const persisted = requirePersistedApprovedPlan(input.ledger, approval);
-    assertTicket20BindingMatchesEvidence(persisted.binding, evidence);
-    const scope = ticket20DataRuleScope(evidence.targetSchemaCode, evidence.targetFieldCode);
-    if (!persisted.allowedOperationScope.includes(scope))
-        throw new Error(`Ticket 20 package step is outside the approved operation scope: ${scope}.`);
-    if (input.pinnedDataRuleContractHash !== ticket20DataRuleContractHash())
-        throw new Error("Ticket 20 pinned data-rule contract hash does not match the canonical 8.6.26 capability contract.");
-    assertDigest(input.knowledgePackDigest, "knowledge pack digest");
-    if (input.knowledgePackDigest !== approval.knowledgePackDigest)
-        throw new Error("Ticket 20 knowledge pack digest diverges from the approved plan binding.");
-    const operation = ticket20DataRuleOperation(evidence);
-    assertTicket20OperationsBounded({ route: TICKET20_DATA_RULE_ROUTE, operations: [operation], targetSchemaCode: evidence.targetSchemaCode, targetFieldCode: evidence.targetFieldCode });
-    const snapshotBase = { id: `snapshot:${operation.id}`, target: operation.target, identity: operation.target, recoveryBoundary: operation.target, state: "absent", baselineFingerprint: persisted.binding.baselineFingerprint };
-    const snapshot = { ...snapshotBase, snapshotHash: digest(snapshotBase) };
-    const pkg = compileNativeOperations({
-        operations: [operation],
-        binding: persisted.binding,
-        planApproval: persisted,
-        snapshotManifest: [snapshot],
-        releasePlanHash: digest("ticket20-no-release"),
-        recoveryPolicyHash: digest("ticket20-data-rule-step-only"),
-        knowledgePack: { id: TICKET20_DATA_RULE_KNOWLEDGE_PACK_ID, digest: input.knowledgePackDigest },
-        capabilityEvidence: [TICKET20_DATA_RULE_CAPABILITY_ID, "cloudpivot.data-rule-create.serialized-server-8.6.26", TICKET20_RULE_READBACK_ENDPOINT, `requiredField:${evidence.targetFieldCode}`, ...evidence.targetFieldCodes.map((fieldCode) => `familyField:${fieldCode}`), `formDraftHandoff:${evidence.handoff.formDraftPackageId}`, `folder:${evidence.folder.id}`, `testRunId:${evidence.testRunId}`, `baselineFingerprint:${persisted.binding.baselineFingerprint}`],
-        requiredPermissions: ["configuration-write"],
-        packageId: `ticket20-data-rule-${digest(persisted.approvalId).slice(0, 32)}`,
-        ledger: input.ledger,
-    });
-    input.ledger.createPackage(pkg);
-    return { package: pkg, operations: [operation], planApproval: persisted, dryRun: ticket20DryRun(evidence, [operation]), evidence };
-}
-/** Read-only dry-run projection; never a CloudPivot write and never a conditional-rule or rule-update operation. */
-function ticket20DryRun(evidence, operations) {
-    const readbackOperations = [
-        { id: `readback:rule:${evidence.targetSchemaCode}:4`, method: "GET", path: TICKET20_RULE_READBACK_ENDPOINT, target: `rule:${evidence.targetSchemaCode}/${evidence.targetFieldCode}`, payload: { schemaCode: evidence.targetSchemaCode, dataRuleType: 4 }, expectedReadback: `rule:${evidence.targetSchemaCode}/${evidence.targetFieldCode}:read`, evidence: ["BizDataRuleController.java:86-427"] },
-        { id: `readback:rule:${evidence.targetSchemaCode}:5`, method: "GET", path: TICKET20_RULE_READBACK_ENDPOINT, target: `rule:${evidence.targetSchemaCode}/${evidence.targetFieldCode}`, payload: { schemaCode: evidence.targetSchemaCode, dataRuleType: 5 }, expectedReadback: `rule:${evidence.targetSchemaCode}/${evidence.targetFieldCode}:read`, evidence: ["BizDataRuleController.java:86-427"] },
-    ];
-    const body = JSON.stringify({ execution: "read-only-dry-run", operations, readbackOperations, blocked: [], prohibitedActions: ["cloudpivot-write"] }, null, 2) + "\n";
-    return { execution: "read-only-dry-run", operations, readbackOperations, blocked: [], prohibitedActions: ["cloudpivot-write"], artifact: { name: "cloudpivot-ticket20-data-rule-dry-run.json", body, sha256: digest(body), mimeType: "application/json" } };
-}
-export function formatTicket20DeliveryPlanApprovalFrame(approval) {
-    const value = requireTicket20Approval(approval);
-    return appendApprovalHumanBlock(`Approve Ticket 20 data rule Delivery Plan Approval ${value.approvalId} hash ${value.approvalHash}; plan hash ${value.planHash}; capability ${value.capabilityId}; environment test; application test; environment fingerprint ${value.binding.environmentFingerprint}; baseline fingerprint ${value.binding.baselineFingerprint}; folder ${value.folderId} (${value.folderName}); fixture model ${value.targetSchemaCode}; required field ${value.targetFieldCode} (the ${fieldFamilyRuleDemoMember().propertyTypeName} member of ${fieldFamilyMemberNamesProse()}); testRunId ${value.testRunId}; exact scope ${value.allowedOperationScope[0]}; one designer-native required-rule create step (POST ${TICKET20_DATA_RULE_ENDPOINT} with the platform writer's exact four-member BizDataRuleModel: schemaCode, propertyCodes [${value.targetFieldCode}], dataRuleType 4, options {"requiredFormula":"true","functionType":"true"}) — the authoring surface the designer panel itself hydrates required/readonly conditions from (type-matrix §9); never a conditional rule, rule update, form write, app publish, or Environment release — with authoritative rule-list readback, empty-condition parity gates, behavior validation, and the stated cascade cleanup contract.`, { capability: "ticket20-data-rule", kind: "delivery-plan", identities: [value.targetSchemaCode, value.targetFieldCode], scope: [value.allowedOperationScope[0]] });
-}
-export function formatTicket20EnvironmentChangeApprovalFrame(input) {
-    const value = requireTicket20Approval(input.approval);
-    return appendApprovalHumanBlock(`Approve Ticket 20 data rule Environment Change Approval for package ${input.packageId} hash ${input.packageHash}; plan approval ${value.approvalId} hash ${value.approvalHash}; environment test; folder ${value.folderId} (${value.folderName}); fixture model ${value.targetSchemaCode}; required field ${value.targetFieldCode}; testRunId ${value.testRunId}; exact scope ${value.allowedOperationScope[0]}; exactly one designer-native required-rule create step (dataRuleType 4, options {"requiredFormula":"true","functionType":"true"}, propertyCodes [${value.targetFieldCode}]) executed by the single Forge configuration writer lease with the authoritative rule-list readback and the no-conditional-rows proof.`, { capability: "ticket20-data-rule", kind: "environment-change", identities: [value.targetSchemaCode, value.targetFieldCode], scope: [value.allowedOperationScope[0]] });
-}
-/**
- * Validates real data-rule behavior beyond HTTP 2xx: the authoritative
- * bizdatarule/list?schemaCode&dataRuleType=4 readback decodes our rule row
- * bound to the field with the pinned options; NO dataRuleType 5 rows exist;
- * and the draft control options still decode with visible + the
- * always-readonly boolean and WITHOUT any condition strings (§9: the rule
- * rows are the authoring surface; the options strings are hydration
- * targets).
- */
-export function validateTicket20DataRuleBehavior(input) {
-    const evidence = validateTicket20Evidence(input.evidence);
-    const checks = [];
-    const add = (id, ok, detail) => checks.push({ id, status: ok ? "validated" : "blocked", detail });
-    const requiredRuleList = input.requiredRuleList;
-    const listOk = requiredRuleList.classification === "present" && requiredRuleList.query.schemaCode === evidence.targetSchemaCode && requiredRuleList.query.dataRuleType === 4;
-    add("required-rule-list-decoded", listOk, listOk ? `the authoritative rule-list readback decoded ${String(requiredRuleList.rows.length)} dataRuleType=4 row(s) for the fixture schema.` : "the authoritative dataRuleType=4 rule-list readback did not decode after the create returned success.");
-    const boundRow = listOk ? requiredRuleList.rows.find((row) => decodeRequiredDataRuleRow(row, evidence.targetSchemaCode, evidence.targetFieldCode) !== undefined) : undefined;
-    add("required-rule-row-bound", Boolean(boundRow), boundRow ? `the required-rule row decodes bound to the TIME field ${evidence.targetFieldCode} through propertyCodes.` : `the authoritative dataRuleType=4 rule list does not carry our rule row bound to the field ${evidence.targetFieldCode}.`);
-    const decodedRow = boundRow ? decodeRequiredDataRuleRow(boundRow, evidence.targetSchemaCode, evidence.targetFieldCode) : undefined;
-    const optionsOk = decodedRow !== undefined && decodedRow.options.requiredFormula === "true" && decodedRow.options.functionType === "true";
-    add("required-rule-options-decoded", optionsOk, optionsOk ? 'the row options decode as the pinned unconditional contract {requiredFormula:"true", functionType:"true"}.' : `the row options did not decode as the pinned unconditional contract (got ${boundRow ? JSON.stringify(boundRow.options) : "no row"}).`);
-    const readonlyRuleList = input.readonlyRuleList;
-    const noConditional = readonlyRuleList.classification === "present" && readonlyRuleList.query.dataRuleType === 5 && readonlyRuleList.rows.length === 0;
-    add("no-conditional-readonly-rules", noConditional, noConditional ? "the authoritative dataRuleType=5 rule list decodes zero rows — nothing conditional was authored." : "the authoritative dataRuleType=5 rule list did not decode as zero rows; conditional rules are outside this capability.");
-    // §9 re-gate on the post-create draft state: the controls still carry
-    // visible + the always-readonly boolean and NO condition strings.
-    evidence.targetFieldCodes.forEach((fieldCode, index) => {
-        const binding = CLOUDPIVOT_8_6_26_SERIALIZED_FORM_DRAFT.boundControls[index];
-        const suffix = binding.propertyTypeName.toLowerCase();
-        const presence = decodeTicket11DraftControlPresence(input.formDraftState.form ?? { draftViewJson: null, draftAttributesJson: null }, fieldCode);
-        const control = presence.control;
-        let optionsOkForControl = false;
-        if (control) {
-            try {
-                assertFamilyControlOptions(CLOUDPIVOT_8_6_26_SERIALIZED_FORM_DRAFT.boundControls, control, binding.propertyTypeName, { schemaCode: evidence.targetSchemaCode, memberFieldCodes: evidence.targetFieldCodes });
-                optionsOkForControl = true;
-            }
-            catch {
-                optionsOkForControl = false;
-            }
-        }
-        add(`draft-control-options-${suffix}-no-condition-strings`, optionsOkForControl, optionsOkForControl
-            ? `the ${binding.propertyTypeName} control options still decode with the pinned keys and WITHOUT requiredFormula/readonlyCondition condition strings (the rule rows are the authoring surface).`
-            : `the ${binding.propertyTypeName} control options failed the §9 re-gate on the post-create draft readback.`);
-    });
-    // Ticket 03b: the always-readonly demo check (id + wording) is the ACTIVE
-    // family's registered descriptor, and its member position selects the
-    // re-gated control selected by the ACTIVE family's registered position.
-    const alwaysReadonlyFieldCode = evidence.targetFieldCodes[activeFieldFamily().alwaysReadonlyDemoPosition - 1];
-    const visibleReadonlyOk = Boolean(input.formDraftState.form) && (() => {
-        const control = input.formDraftState.form ? decodeDraftControl(input.formDraftState.form.draftViewJson, input.formDraftState.form.draftAttributesJson, alwaysReadonlyFieldCode) : undefined;
-        return control?.options?.visible === true && control.options.readonlyFormula === true;
-    })();
-    add(activeFieldFamily().alwaysReadonlyDemoCheck.id, visibleReadonlyOk, visibleReadonlyOk ? activeFieldFamily().alwaysReadonlyDemoCheck.passDetail : activeFieldFamily().alwaysReadonlyDemoCheck.failDetail);
-    const blocked = checks.find((check) => check.status === "blocked");
-    return blocked ? { status: "blocked", reason: `Ticket 20 behavior validation failed: ${blocked.detail}`, checks } : { status: "validated", checks };
-}
-/** Execution boundary: named test environment, route-bound package steps, active approvals, no replay of terminal or uncertain packages. */
-export function assertTicket20ExecutionBoundary(input) {
-    if (input.environmentName !== "test")
-        throw new Error("Ticket 20 execution is restricted to the named test environment; production and staging are rejected.");
-    const { projection } = input;
-    if (input.steps.length !== 1 || !input.steps[0].id.startsWith("rule-create:"))
-        throw new Error(`Ticket 20 execution boundary rejected package ${input.packageId}: its steps are not the single rule-create: operation bound to the ${input.route} route.`);
-    if (projection.status === "approved" && projection.approvals.plan === "approved" && projection.approvals.environment === "approved")
-        return;
-    if (projection.status === "completed")
-        throw new Error(`Ticket 20 package ${input.packageId} is already terminal completed; replay is rejected.`);
-    if (projection.status === "uncertain")
-        throw new Error(`Ticket 20 package ${input.packageId} is uncertain; reconcile by authoritative readback before any replay.`);
-    if (projection.status === "in_progress")
-        throw new Error(`Ticket 20 package ${input.packageId} is already running; concurrent execution is rejected.`);
-    const pending = [...projection.blockers];
-    if (projection.approvals.plan !== "approved")
-        pending.push("Delivery Plan Approval is required before package execution.");
-    if (projection.approvals.environment !== "approved")
-        pending.push("Environment Change Approval is required before mutation.");
-    throw new Error(`Ticket 20 execution boundary rejected package ${input.packageId}: status is ${projection.status} (blocked); ${[...new Set(pending)].join("; ")}.`);
-}
-/** Executes the approved one-step required-rule create package through the single OMC Host write transport, then validates the rule row and the no-conditional proofs. */
-export async function executeTicket20DataRulePackage(input) {
-    assertTicket20TestDataRuleEnvironment(input.settings);
-    if (typeof input.transport.serializedServerDataRuleCreate !== "function")
-        throw new Error("Ticket 20 execution requires the OMC Host serialized data-rule transport; bypass transports are rejected.");
-    const projection = input.ledger.project(input.prepared.package.packageId);
-    assertTicket20ExecutionBoundary({ projection, environmentName: input.settings.environmentName, packageId: input.prepared.package.packageId, route: TICKET20_DATA_RULE_ROUTE, steps: input.prepared.package.steps });
-    if (input.environmentApproval.packageId !== input.prepared.package.packageId || input.environmentApproval.packageHash !== input.prepared.package.packageHash)
-        throw new Error("Ticket 20 Environment Change Approval does not match the prepared package.");
-    const evidence = input.prepared.evidence;
-    const preflightRequired = await input.readRequiredRuleList();
-    if (preflightRequired.classification !== "present")
-        throw new Error("Ticket 20 execution requires the authoritative rule-list readback to decode before the write.");
-    if (preflightRequired.rows.some((row) => decodeRequiredDataRuleRow(row, evidence.targetSchemaCode, evidence.targetFieldCode) !== undefined))
-        throw new Error(`Ticket 20 execution requires exact required-rule absence before the create; ${evidence.targetFieldCode} already carries a bound rule row.`);
-    const preflightReadonly = await input.readonlyRuleList();
-    if (preflightReadonly.classification !== "present" || preflightReadonly.rows.length)
-        throw new Error("Ticket 20 execution requires zero conditional-readonly rules on the fixture schema before the write.");
-    const result = await runNativeConfigurationPackage({
-        package: input.prepared.package,
-        gate: {
-            mode: "approved",
-            planApproval: { status: "approved", approvalHash: input.prepared.planApproval.approvalHash },
-            environmentApproval: { status: "approved", packageHash: input.environmentApproval.packageHash },
-            lease: { owner: "configuration-agent", environment: TICKET20_TEST_ENVIRONMENT_NAME },
-            baselineFingerprint: input.prepared.package.binding.baselineFingerprint,
-            snapshots: input.prepared.package.snapshotManifest,
-            package: input.prepared.package,
-        },
-        operations: input.prepared.operations,
-        ledger: input.ledger,
-        planApproval: input.prepared.planApproval,
-        transport: input.transport,
-        credentials: input.credentials,
-        authoritativeOrigin: input.authoritativeOrigin,
-        testApplicationCode: TICKET20_TEST_APPLICATION_CODE,
-    }, input.signal);
-    const mutationExecuted = result.steps.some((step) => step.status === "committed" || step.status === "uncertain");
-    const blockers = [...result.blockers];
-    let status = ticket20ExecutionStatus(result.status);
-    let nextAction = result.nextAction;
-    let behavior;
-    if (result.status === "completed") {
-        behavior = validateTicket20DataRuleBehavior({ evidence, requiredRuleList: await input.readRequiredRuleList(), readonlyRuleList: await input.readonlyRuleList(), formDraftState: await input.readFormDraftState() });
-        if (behavior.status !== "validated") {
-            status = "blocked";
-            blockers.push(behavior.reason ?? "Ticket 20 behavior validation failed.");
-            nextAction = "reconcile-behavior-retain-and-report-resource";
-        }
-    }
-    return { reportType: "omc.ticket20.test-data-rule-execution", schemaVersion: 1, packageId: result.packageId, packageHash: result.packageHash, route: TICKET20_DATA_RULE_ROUTE, testRunId: evidence.testRunId, targetSchemaCode: evidence.targetSchemaCode, targetSheetCode: evidence.targetSheetCode, targetFieldCodes: evidence.targetFieldCodes, targetFieldCode: evidence.targetFieldCode, status, mutationExecuted, steps: result.steps, blockers, nextAction, ...(behavior ? { behavior } : {}) };
-}
-/**
- * Closes the stated rule cascade cleanup contract: after the separately
- * approved staged cleanup (published-field cleanup, then the model physical
- * delete), the authoritative bizdatarule/list readback must decode zero
- * rows for the fixture schema (or the recorded schema-absence envelope).
- * Anything else stops, retains, and reports.
- */
-export function confirmTicket20RuleCascadeAbsence(input) {
-    const evidence = validateTicket20Evidence(input.evidence);
-    const readback = input.ruleListReadback;
-    if (readback.query.schemaCode !== evidence.targetSchemaCode || readback.query.dataRuleType !== 4)
-        throw new Error("Ticket 20 rule cascade confirmation requires the dataRuleType=4 list readback for the fixture schema.");
-    if (readback.classification === "absent")
-        return;
-    if (readback.classification !== "present" || readback.rows.length !== 0)
-        throw new Error(`Ticket 20 rule cascade cleanup contract is not closed: the bizdatarule/list readback still decodes ${String(readback.rows.length)} row(s) after the model physical delete (classification=${readback.classification}); if the live cascade leaves survivors, execute the pinned /delete?id fallback explicitly and stop, retain, and report.`);
-}
-function ticket20ExecutionStatus(status) {
-    if (status === "completed" || status === "uncertain" || status === "partial")
-        return status;
-    return "blocked";
-}
-function requireTicket20Approval(approval) {
-    const value = approval;
-    if (value.route !== TICKET20_DATA_RULE_ROUTE || value.capabilityId !== TICKET20_DATA_RULE_CAPABILITY_ID || value.environmentName !== "test" || value.applicationCode !== "test" || value.targets?.length !== 1 || !value.folderId || !value.folderName || !value.testRunId || !value.targetSchemaCode || !value.targetSheetCode || !Array.isArray(value.targetFieldCodes) || value.targetFieldCodes.length !== TICKET09_FIELD_FAMILY.length || value.targetFieldCodes.some((code) => !isTicket09TargetField(code)) || new Set(value.targetFieldCodes).size !== TICKET09_FIELD_FAMILY.length || !isTicket09TargetField(value.targetFieldCode) || value.targetFieldCode !== value.targetFieldCodes[activeFieldFamily().ruleDemoTargetPosition - 1])
-        throw new Error(`Ticket 20 approval frame is not bound to the exact ${TICKET20_DATA_RULE_ROUTE} route, family targets, required field, folder, and testRunId.`);
-    return value;
-}
-function requirePersistedApprovedPlan(ledger, approval) {
-    if (approval.status !== "approved")
-        throw new Error("Ticket 20 package preparation requires the approved exact Ticket 20 Delivery Plan Approval.");
-    const persisted = ledger.findPlanApproval(approval.approvalId);
-    if (!persisted || persisted.status !== "approved" || persisted.approvalHash !== approval.approvalHash)
-        throw new Error("Ticket 20 package preparation requires the exact authoritative approved Delivery Plan Approval.");
-    return persisted;
-}
-function assertTicket20BindingMatchesEvidence(binding, evidence) {
-    const expected = {
-        deliveryId: ticket20DeliveryId(evidence.testRunId),
-        environment: TICKET20_TEST_ENVIRONMENT_NAME,
-        baselineFingerprint: evidence.baselineFingerprint,
-        environmentFingerprint: evidence.environmentFingerprint,
-        discoveryFingerprint: evidence.discoveryFingerprint,
-        ...(evidence.evidenceArtifactId ? { evidenceArtifactId: evidence.evidenceArtifactId } : {}),
-    };
-    if (stable(binding) !== stable(expected))
-        throw new Error("Ticket 20 plan approval binding is outside the evidence baseline, environment, discovery, or delivery binding.");
-}
-function validateTicket20Evidence(evidence) {
-    if (!evidence || evidence.route !== TICKET20_DATA_RULE_ROUTE || evidence.capabilityId !== TICKET20_DATA_RULE_CAPABILITY_ID)
-        throw new Error("Ticket 20 evidence is not the host-owned data-rule route.");
-    if (evidence.environmentName !== "test" || evidence.applicationCode !== "test")
-        throw new Error("Ticket 20 evidence is outside the named test environment and dedicated test application.");
-    if (!isTicket08TargetSchema(evidence.targetSchemaCode))
-        throw new Error("Ticket 20 evidence fixture model is not the host-owned Ticket 08 schema.");
-    if (!Array.isArray(evidence.targetFieldCodes) || evidence.targetFieldCodes.length !== TICKET09_FIELD_FAMILY.length || evidence.targetFieldCodes.some((code) => !isTicket09TargetField(code)) || new Set(evidence.targetFieldCodes).size !== TICKET09_FIELD_FAMILY.length)
-        throw new Error("Ticket 20 evidence family field codes are not the distinct host-owned Ticket 09 field codes (one per active family member).");
-    if (!isTicket09TargetField(evidence.targetFieldCode) || evidence.targetFieldCode !== evidence.targetFieldCodes[activeFieldFamily().ruleDemoTargetPosition - 1])
-        throw new Error("Ticket 20 evidence required field is not the active family's registered rule-demo member.");
-    if (evidence.ruleContract.dataRuleType !== 4 || evidence.ruleContract.options !== CLOUDPIVOT_8_6_26_SERIALIZED_DATA_RULE_CREATE.ruleContract.options || evidence.ruleContract.propertyTypeName !== fieldFamilyRuleDemoMember().propertyTypeName)
-        throw new Error("Ticket 20 evidence rule contract is not the pinned unconditional required rule.");
-    if ([evidence.environmentFingerprint, evidence.baselineFingerprint, evidence.discoveryFingerprint].some((value) => !SHA256.test(value)))
-        throw new Error("Ticket 20 evidence fingerprints are not canonical.");
-    if (evidence.modelPresence.classification !== "present" || evidence.modelPresence.query.schemaCode !== evidence.targetSchemaCode)
-        throw new Error("Ticket 20 evidence does not carry the authoritative fixture model presence handoff.");
-    evidence.targetFieldCodes.forEach((fieldCode, index) => {
-        const presence = evidence.publishedFieldPresence[index];
-        if (presence?.classification !== "present" || presence.query.schemaCode !== evidence.targetSchemaCode || presence.query.propertyCode !== fieldCode || presence.query.isPublish !== "true" || presence.field?.published !== true)
-            throw new Error("Ticket 20 evidence does not carry exact authenticated published family field presence.");
-    });
-    if (evidence.formDraftState.classification !== "present" || evidence.formDraftState.query.schemaCode !== evidence.targetSchemaCode || evidence.formDraftState.query.sheetCode !== evidence.targetSheetCode || !evidence.formDraftState.form || evidence.formDraftState.form.published !== false)
-        throw new Error("Ticket 20 evidence does not carry the exact authenticated draft-configured form state.");
-    if (evidence.requiredRulePreState.classification !== "present" || evidence.requiredRulePreState.query.dataRuleType !== 4 || evidence.readonlyRulePreState.classification !== "present" || evidence.readonlyRulePreState.query.dataRuleType !== 5)
-        throw new Error("Ticket 20 evidence does not carry the exact authenticated rule-list pre-states.");
-    if (!evidence.folder.id || !evidence.folder.name)
-        throw new Error("Ticket 20 evidence folder binding is missing.");
-    return evidence;
-}
-function assertDigest(value, label) {
-    if (typeof value !== "string" || !SHA256.test(value) || !/[1-9a-f]/i.test(value))
-        throw new Error(`Ticket 20 ${label} is invalid.`);
-}
-function digest(value) { return createHash("sha256").update(stable(value)).digest("hex"); }
-function stable(value) { return JSON.stringify(sort(value)); }
-function sort(value) { if (Array.isArray(value))
-    return value.map(sort); if (value && typeof value === "object")
-    return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, sort(item)])); return value; }
-//# sourceMappingURL=ticket20-test-data-rule.js.map