@xyo-network/xl1-protocol 5.2.0 → 5.2.2

package/dist/neutral/modules/network-model/staticRest/layout/admissionShadow.d.ts

@@ -0,0 +1,181 @@
+import { z } from 'zod';
+/** Schema id for a published admission shadow report. */
+export declare const AdmissionShadowReportSchema: "network.xyo.s3.admission.shadow" & {
+    readonly __schema: true;
+};
+/** Type literal for the admission shadow report schema. */
+export type AdmissionShadowReportSchema = typeof AdmissionShadowReportSchema;
+/** What both admission gates concluded about one candidate. */
+export declare const AdmissionShadowAssessmentZod: z.ZodObject<{
+    activeStake: z.ZodOptional<z.ZodString>;
+    admittedByAllowList: z.ZodBoolean;
+    block: z.ZodInt;
+    dataHash: z.ZodString;
+    eStar: z.ZodOptional<z.ZodInt>;
+    eligible: z.ZodOptional<z.ZodBoolean>;
+    intentValid: z.ZodOptional<z.ZodBoolean>;
+    producer: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    resolvable: z.ZodBoolean;
+    selfBond: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** What both admission gates concluded about one candidate. */
+export type AdmissionShadowAssessment = z.infer<typeof AdmissionShadowAssessmentZod>;
+/**
+ * Zod schema for one published round of shadow admission.
+ *
+ * Published rather than logged because the point of the posture is that anyone can see what
+ * enforcement would have done before it does it. An operator convinced by their own logs has
+ * convinced nobody.
+ *
+ * The back-link is what makes the series walkable without listing: a reader takes the head
+ * pointer and follows `previous` as far back as it cares to.
+ */
+export declare const AdmissionShadowReportZod: z.ZodObject<{
+    assessments: z.ZodArray<z.ZodObject<{
+        activeStake: z.ZodOptional<z.ZodString>;
+        admittedByAllowList: z.ZodBoolean;
+        block: z.ZodInt;
+        dataHash: z.ZodString;
+        eStar: z.ZodOptional<z.ZodInt>;
+        eligible: z.ZodOptional<z.ZodBoolean>;
+        intentValid: z.ZodOptional<z.ZodBoolean>;
+        producer: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+        resolvable: z.ZodBoolean;
+        selfBond: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    divergent: z.ZodArray<z.ZodObject<{
+        activeStake: z.ZodOptional<z.ZodString>;
+        admittedByAllowList: z.ZodBoolean;
+        block: z.ZodInt;
+        dataHash: z.ZodString;
+        eStar: z.ZodOptional<z.ZodInt>;
+        eligible: z.ZodOptional<z.ZodBoolean>;
+        intentValid: z.ZodOptional<z.ZodBoolean>;
+        producer: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+        resolvable: z.ZodBoolean;
+        selfBond: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    head: z.ZodInt;
+    mode: z.ZodOptional<z.ZodEnum<{
+        shadow: "shadow";
+        enforce: "enforce";
+    }>>;
+    previous: z.ZodOptional<z.ZodInt>;
+    schema: z.ZodLiteral<"network.xyo.s3.admission.shadow" & {
+        readonly __schema: true;
+    }>;
+}, z.core.$strip>;
+/** One published round of shadow admission. */
+export type AdmissionShadowReportDocument = z.infer<typeof AdmissionShadowReportZod>;
+/** Type guard that checks if a value is a valid AdmissionShadowReportDocument. */
+export declare const isAdmissionShadowReport: <T>(value: T) => value is T & {
+    assessments: {
+        admittedByAllowList: boolean;
+        block: number;
+        dataHash: string;
+        producer: string;
+        resolvable: boolean;
+        activeStake?: string | undefined;
+        eStar?: number | undefined;
+        eligible?: boolean | undefined;
+        intentValid?: boolean | undefined;
+        reason?: string | undefined;
+        selfBond?: string | undefined;
+    }[];
+    divergent: {
+        admittedByAllowList: boolean;
+        block: number;
+        dataHash: string;
+        producer: string;
+        resolvable: boolean;
+        activeStake?: string | undefined;
+        eStar?: number | undefined;
+        eligible?: boolean | undefined;
+        intentValid?: boolean | undefined;
+        reason?: string | undefined;
+        selfBond?: string | undefined;
+    }[];
+    head: number;
+    schema: "network.xyo.s3.admission.shadow" & {
+        readonly __schema: true;
+    };
+    mode?: "shadow" | "enforce" | undefined;
+    previous?: number | undefined;
+};
+/** Converts a value to AdmissionShadowReportDocument, throwing if invalid. */
+export declare const asAdmissionShadowReport: {
+    <T>(value: T): (T & {
+        assessments: {
+            admittedByAllowList: boolean;
+            block: number;
+            dataHash: string;
+            producer: string;
+            resolvable: boolean;
+            activeStake?: string | undefined;
+            eStar?: number | undefined;
+            eligible?: boolean | undefined;
+            intentValid?: boolean | undefined;
+            reason?: string | undefined;
+            selfBond?: string | undefined;
+        }[];
+        divergent: {
+            admittedByAllowList: boolean;
+            block: number;
+            dataHash: string;
+            producer: string;
+            resolvable: boolean;
+            activeStake?: string | undefined;
+            eStar?: number | undefined;
+            eligible?: boolean | undefined;
+            intentValid?: boolean | undefined;
+            reason?: string | undefined;
+            selfBond?: string | undefined;
+        }[];
+        head: number;
+        schema: "network.xyo.s3.admission.shadow" & {
+            readonly __schema: true;
+        };
+        mode?: "shadow" | "enforce" | undefined;
+        previous?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        assessments: {
+            admittedByAllowList: boolean;
+            block: number;
+            dataHash: string;
+            producer: string;
+            resolvable: boolean;
+            activeStake?: string | undefined;
+            eStar?: number | undefined;
+            eligible?: boolean | undefined;
+            intentValid?: boolean | undefined;
+            reason?: string | undefined;
+            selfBond?: string | undefined;
+        }[];
+        divergent: {
+            admittedByAllowList: boolean;
+            block: number;
+            dataHash: string;
+            producer: string;
+            resolvable: boolean;
+            activeStake?: string | undefined;
+            eStar?: number | undefined;
+            eligible?: boolean | undefined;
+            intentValid?: boolean | undefined;
+            reason?: string | undefined;
+            selfBond?: string | undefined;
+        }[];
+        head: number;
+        schema: "network.xyo.s3.admission.shadow" & {
+            readonly __schema: true;
+        };
+        mode?: "shadow" | "enforce" | undefined;
+        previous?: number | undefined;
+    };
+};
+/** Builds a validated admission shadow report. */
+export declare function createAdmissionShadowReport(head: number, assessments: AdmissionShadowAssessment[], divergent: AdmissionShadowAssessment[], previous?: number, mode?: AdmissionShadowReportDocument['mode']): AdmissionShadowReportDocument;
+//# sourceMappingURL=admissionShadow.d.ts.map

package/dist/neutral/modules/network-model/staticRest/layout/admissionShadow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admissionShadow.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/admissionShadow.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,yDAAyD;AACzD,eAAO,MAAM,2BAA2B;;CAAoD,CAAA;AAC5F,2DAA2D;AAC3D,MAAM,MAAM,2BAA2B,GAAG,OAAO,2BAA2B,CAAA;AAE5E,+DAA+D;AAC/D,eAAO,MAAM,4BAA4B;;;;;;;;;;;;iBAuBvC,CAAA;AAEF,+DAA+D;AAC/D,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEpF;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYnC,CAAA;AAEF,+CAA+C;AAC/C,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEpF,kFAAkF;AAClF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAyC,CAAA;AAC7E,8EAA8E;AAC9E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoE,CAAA;AAExG,kDAAkD;AAClD,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,yBAAyB,EAAE,EACxC,SAAS,EAAE,yBAAyB,EAAE,EACtC,QAAQ,CAAC,EAAE,MAAM,EACjB,IAAI,CAAC,EAAE,6BAA6B,CAAC,MAAM,CAAC,GAC3C,6BAA6B,CAI/B"}

package/dist/neutral/modules/network-model/staticRest/layout/chainParams.d.ts

@@ -17,6 +17,8 @@ export declare const RuleIdZod: z.ZodEnum<{
     "eligibility-admission": "eligibility-admission";
     "attestation-admission": "attestation-admission";
     "certificate-execution": "certificate-execution";
+    "fork-choice-v2": "fork-choice-v2";
+    "bridge-value-ceiling": "bridge-value-ceiling";
     "equivocation.reportable": "equivocation.reportable";
     "invalid-block.reportable": "invalid-block.reportable";
     "reward-overmint.reportable": "reward-overmint.reportable";
@@ -49,6 +51,8 @@ export declare const ChainParamsZod: z.ZodObject<{
         "eligibility-admission": "eligibility-admission";
         "attestation-admission": "attestation-admission";
         "certificate-execution": "certificate-execution";
+        "fork-choice-v2": "fork-choice-v2";
+        "bridge-value-ceiling": "bridge-value-ceiling";
         "equivocation.reportable": "equivocation.reportable";
         "invalid-block.reportable": "invalid-block.reportable";
         "reward-overmint.reportable": "reward-overmint.reportable";
@@ -81,6 +85,8 @@ export declare const ChainParamsZod: z.ZodObject<{
         "eligibility-admission": "eligibility-admission";
         "attestation-admission": "attestation-admission";
         "certificate-execution": "certificate-execution";
+        "fork-choice-v2": "fork-choice-v2";
+        "bridge-value-ceiling": "bridge-value-ceiling";
         "equivocation.reportable": "equivocation.reportable";
         "invalid-block.reportable": "invalid-block.reportable";
         "reward-overmint.reportable": "reward-overmint.reportable";
@@ -138,7 +144,7 @@ export type ChainParams = z.infer<typeof ChainParamsZod>;
 export type ChainParamsInput = z.input<typeof ChainParamsZod>;
 /** Type guard that checks if a value is a valid ChainParams. */
 export declare const isChainParams: <T>(value: T) => value is T & {
-    activations: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>>;
+    activations: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "fork-choice-v2" | "bridge-value-ceiling" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>>;
     arbiter: string;
     attestationRewardBps: number;
     bountyCapAtto: string;
@@ -171,12 +177,12 @@ export declare const isChainParams: <T>(value: T) => value is T & {
     slashFractionsBps: Partial<Record<"equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation", number>>;
     slashQuorumCount: number;
     version: number;
-    deactivations?: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>> | undefined;
+    deactivations?: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "fork-choice-v2" | "bridge-value-ceiling" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>> | undefined;
 };
 /** Converts a value to ChainParams, throwing if invalid. */
 export declare const asChainParams: {
     <T>(value: T): (T & {
-        activations: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>>;
+        activations: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "fork-choice-v2" | "bridge-value-ceiling" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>>;
         arbiter: string;
         attestationRewardBps: number;
         bountyCapAtto: string;
@@ -209,10 +215,10 @@ export declare const asChainParams: {
         slashFractionsBps: Partial<Record<"equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation", number>>;
         slashQuorumCount: number;
         version: number;
-        deactivations?: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>> | undefined;
+        deactivations?: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "fork-choice-v2" | "bridge-value-ceiling" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>> | undefined;
     }) | undefined;
     <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
-        activations: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>>;
+        activations: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "fork-choice-v2" | "bridge-value-ceiling" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>>;
         arbiter: string;
         attestationRewardBps: number;
         bountyCapAtto: string;
@@ -245,13 +251,13 @@ export declare const asChainParams: {
         slashFractionsBps: Partial<Record<"equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation", number>>;
         slashQuorumCount: number;
         version: number;
-        deactivations?: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>> | undefined;
+        deactivations?: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "fork-choice-v2" | "bridge-value-ceiling" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>> | undefined;
     };
 };
 /** Non-validating cast to ChainParams. */
 export declare const toChainParams: {
     (value: unknown): {
-        activations: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>>;
+        activations: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "fork-choice-v2" | "bridge-value-ceiling" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>>;
         arbiter: string;
         attestationRewardBps: number;
         bountyCapAtto: string;
@@ -284,10 +290,10 @@ export declare const toChainParams: {
         slashFractionsBps: Partial<Record<"equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation", number>>;
         slashQuorumCount: number;
         version: number;
-        deactivations?: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>> | undefined;
+        deactivations?: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "fork-choice-v2" | "bridge-value-ceiling" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>> | undefined;
     } | undefined;
     (value: unknown, assert: import("@ariestools/sdk").ZodFactoryConfig): {
-        activations: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>>;
+        activations: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "fork-choice-v2" | "bridge-value-ceiling" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>>;
         arbiter: string;
         attestationRewardBps: number;
         bountyCapAtto: string;
@@ -320,7 +326,7 @@ export declare const toChainParams: {
         slashFractionsBps: Partial<Record<"equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation", number>>;
         slashQuorumCount: number;
         version: number;
-        deactivations?: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>> | undefined;
+        deactivations?: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "fork-choice-v2" | "bridge-value-ceiling" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>> | undefined;
     };
 };
 /** Schema id for the register head pointer. */

package/dist/neutral/modules/network-model/staticRest/layout/chainParams.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chainParams.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/chainParams.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,2DAA2D;AAC3D,eAAO,MAAM,iBAAiB;;CAAgD,CAAA;AAC9E,4DAA4D;AAC5D,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAA;AAExD,gFAAgF;AAChF,eAAO,MAAM,oBAAoB,IAAI,CAAA;AAKrC,wCAAwC;AACxC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;EAAkB,CAAA;AAKxC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgEzB,CAAA;AAEF,mDAAmD;AACnD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAExD,8EAA8E;AAC9E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE7D,gEAAgE;AAChE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA+B,CAAA;AACzD,4DAA4D;AAC5D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAA;AAC1E,0CAA0C;AAC1C,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAA;AAE1E,+CAA+C;AAC/C,eAAO,MAAM,qBAAqB;;CAAqD,CAAA;AACvF,iDAAiD;AACjD,MAAM,MAAM,qBAAqB,GAAG,OAAO,qBAAqB,CAAA;AAEhE,8EAA8E;AAC9E,eAAO,MAAM,kBAAkB;;;;;;iBAM7B,CAAA;AAEF,+DAA+D;AAC/D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,oEAAoE;AACpE,eAAO,MAAM,iBAAiB;;;;;;CAAmC,CAAA;AACjE,gEAAgE;AAChE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;CAAwD,CAAA;AAEtF,2CAA2C;AAC3C,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,EAAE,QAAQ,CAAC,GAAG,WAAW,CAEvF;AAED,gDAAgD;AAChD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,eAAe,CAIpF"}
+{"version":3,"file":"chainParams.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/chainParams.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,2DAA2D;AAC3D,eAAO,MAAM,iBAAiB;;CAAgD,CAAA;AAC9E,4DAA4D;AAC5D,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAA;AAExD,gFAAgF;AAChF,eAAO,MAAM,oBAAoB,IAAI,CAAA;AAKrC,wCAAwC;AACxC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;EAAkB,CAAA;AAKxC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgEzB,CAAA;AAEF,mDAAmD;AACnD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAExD,8EAA8E;AAC9E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE7D,gEAAgE;AAChE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA+B,CAAA;AACzD,4DAA4D;AAC5D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAA;AAC1E,0CAA0C;AAC1C,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAA;AAE1E,+CAA+C;AAC/C,eAAO,MAAM,qBAAqB;;CAAqD,CAAA;AACvF,iDAAiD;AACjD,MAAM,MAAM,qBAAqB,GAAG,OAAO,qBAAqB,CAAA;AAEhE,8EAA8E;AAC9E,eAAO,MAAM,kBAAkB;;;;;;iBAM7B,CAAA;AAEF,+DAA+D;AAC/D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,oEAAoE;AACpE,eAAO,MAAM,iBAAiB;;;;;;CAAmC,CAAA;AACjE,gEAAgE;AAChE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;CAAwD,CAAA;AAEtF,2CAA2C;AAC3C,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,EAAE,QAAQ,CAAC,GAAG,WAAW,CAEvF;AAED,gDAAgD;AAChD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,eAAe,CAIpF"}

package/dist/neutral/modules/network-model/staticRest/layout/chainParamsRules.d.ts

@@ -27,10 +27,25 @@ export declare function protocolMinAt(params: ChainParams, height: number): numb
  * The register is append-only over history: a version may add rules and move future heights, but
  * never rewrite what was true at a height the chain has already passed. Without that, a rule
  * could be made retroactive and blocks that were valid when produced would become offenses.
+ *
+ * The one sanctioned rewrite is re-activation. A rule whose deactivation the chain has passed may
+ * return at a new future height, and the spent deactivation is dropped in the same version — the
+ * heights between read as unenforced either way, and only-forward moves mean history can never be
+ * judged more strictly than it was lived.
  * @param previous The currently published version, when there is one
  * @param next The version being published
  * @param finalizedHeight The current finalized head height
  * @returns The reasons the version may not be published, empty when it may
  */
 export declare function chainParamsSuccessionErrors(previous: ChainParams | undefined, next: ChainParams, finalizedHeight: number): string[];
+/**
+ * Checks the relationships a register version's economics must hold on their own (yellow §11.2).
+ *
+ * Only register-derivable checks live here. The withdrawal-delay inequality needs the staking
+ * contract's delay, so it belongs to the governance runbook that sets these numbers, not to a
+ * document check every reader can run.
+ * @param params The version being judged
+ * @returns The reasons the version is internally inconsistent, empty when it is sound
+ */
+export declare function chainParamsInvariantErrors(params: ChainParams): string[];
 //# sourceMappingURL=chainParamsRules.d.ts.map

package/dist/neutral/modules/network-model/staticRest/layout/chainParamsRules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chainParamsRules.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/chainParamsRules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EAAE,mBAAmB,EACjC,MAAM,iBAAiB,CAAA;AAKxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAEnD,qEAAqE;AACrE,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAExG;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,MAAM,GACb,mBAAmB,CAErB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAErF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,WAAW,GAAG,SAAS,EACjC,IAAI,EAAE,WAAW,EACjB,eAAe,EAAE,MAAM,GACtB,MAAM,EAAE,CAqBV"}
+{"version":3,"file":"chainParamsRules.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/chainParamsRules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EAAE,mBAAmB,EACjC,MAAM,iBAAiB,CAAA;AAKxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAEnD,qEAAqE;AACrE,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAExG;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,MAAM,GACb,mBAAmB,CAErB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAErF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,WAAW,GAAG,SAAS,EACjC,IAAI,EAAE,WAAW,EACjB,eAAe,EAAE,MAAM,GACtB,MAAM,EAAE,CAwCV;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,EAAE,CAmBxE"}

package/dist/neutral/modules/network-model/staticRest/layout/index.d.ts

@@ -1,3 +1,4 @@
+export * from './admissionShadow.js';
 export * from './chainContractManifest.js';
 export * from './chainManifest.js';
 export * from './chainParams.js';
@@ -5,6 +6,7 @@ export * from './chainParamsRules.js';
 export * from './evmEventIndex.js';
 export * from './indexManifest.js';
 export * from './networkStakeRewardsIndex.js';
+export * from './slashIndex.js';
 export * from './transactionInclusionIndex.js';
 export * from './trustedPosture.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/network-model/staticRest/layout/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA;AAC1C,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,qBAAqB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AACpC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gCAAgC,CAAA;AAC9C,cAAc,qBAAqB,CAAA"}

package/dist/neutral/modules/network-model/staticRest/layout/slashIndex.d.ts

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+/** Schema id for the slash index head pointer. */
+export declare const SlashIndexHeadSchema: "network.xyo.s3.slash.index.head" & {
+    readonly __schema: true;
+};
+/** Type literal for the slash index head schema. */
+export type SlashIndexHeadSchema = typeof SlashIndexHeadSchema;
+/** Bumped when the index layout changes, so readers can detect a mismatch. */
+export declare const SLASH_INDEX_VERSION = 1;
+/**
+ * Zod schema for the slash index head pointer.
+ *
+ * Written last in every pass. A reader that sees this pointer can rely on everything it names
+ * already being there, which is what makes a crashed pass safe to simply re-run: the pointer only
+ * ever advances over work that finished.
+ */
+export declare const SlashIndexHeadZod: z.ZodObject<{
+    height: z.ZodInt;
+    indexVersion: z.ZodInt;
+    schema: z.ZodLiteral<"network.xyo.s3.slash.index.head" & {
+        readonly __schema: true;
+    }>;
+    anchor: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+/** The slash index head pointer. */
+export type SlashIndexHead = z.infer<typeof SlashIndexHeadZod>;
+/** Type guard that checks if a value is a valid SlashIndexHead. */
+export declare const isSlashIndexHead: <T>(value: T) => value is T & {
+    height: number;
+    indexVersion: number;
+    schema: "network.xyo.s3.slash.index.head" & {
+        readonly __schema: true;
+    };
+    anchor?: number | undefined;
+};
+/** Converts a value to SlashIndexHead, throwing if invalid. */
+export declare const asSlashIndexHead: {
+    <T>(value: T): (T & {
+        height: number;
+        indexVersion: number;
+        schema: "network.xyo.s3.slash.index.head" & {
+            readonly __schema: true;
+        };
+        anchor?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        height: number;
+        indexVersion: number;
+        schema: "network.xyo.s3.slash.index.head" & {
+            readonly __schema: true;
+        };
+        anchor?: number | undefined;
+    };
+};
+/** Non-validating cast to SlashIndexHead. */
+export declare const toSlashIndexHead: {
+    (value: unknown): {
+        height: number;
+        indexVersion: number;
+        schema: "network.xyo.s3.slash.index.head" & {
+            readonly __schema: true;
+        };
+        anchor?: number | undefined;
+    } | undefined;
+    (value: unknown, assert: import("@ariestools/sdk").ZodFactoryConfig): {
+        height: number;
+        indexVersion: number;
+        schema: "network.xyo.s3.slash.index.head" & {
+            readonly __schema: true;
+        };
+        anchor?: number | undefined;
+    };
+};
+/** Schema id for the per-offense aggregate. */
+export declare const SlashIndexKeyRecordSchema: "network.xyo.s3.slash.index.key" & {
+    readonly __schema: true;
+};
+/** Type literal for the per-offense aggregate schema. */
+export type SlashIndexKeyRecordSchema = typeof SlashIndexKeyRecordSchema;
+/**
+ * Zod schema for everything recorded about one offense.
+ *
+ * The aggregates are the only discovery surface, because the published read path cannot list
+ * objects. That is why they are allowed to be rewritten while everything else is immutable — and
+ * why every rewrite only appends, so a pass that runs twice converges instead of losing history.
+ */
+export declare const SlashIndexKeyRecordZod: z.ZodObject<{
+    accused: z.ZodString;
+    adjudication: z.ZodOptional<z.ZodString>;
+    block: z.ZodInt;
+    challenges: z.ZodArray<z.ZodString>;
+    chain: z.ZodString;
+    outcome: z.ZodOptional<z.ZodEnum<{
+        confirmed: "confirmed";
+        refuted: "refuted";
+        indeterminate: "indeterminate";
+        invalid: "invalid";
+    }>>;
+    offense: z.ZodEnum<{
+        equivocation: "equivocation";
+        "invalid-block": "invalid-block";
+        "reward-overmint": "reward-overmint";
+        "false-anchor": "false-anchor";
+        "ineligible-production": "ineligible-production";
+        "invalid-slash-request": "invalid-slash-request";
+        "false-attestation": "false-attestation";
+    }>;
+    requests: z.ZodArray<z.ZodString>;
+    schema: z.ZodLiteral<"network.xyo.s3.slash.index.key" & {
+        readonly __schema: true;
+    }>;
+}, z.core.$strip>;
+/** Everything recorded about one offense. */
+export type SlashIndexKeyRecord = z.infer<typeof SlashIndexKeyRecordZod>;
+/** Type guard that checks if a value is a valid SlashIndexKeyRecord. */
+export declare const isSlashIndexKeyRecord: <T>(value: T) => value is T & {
+    accused: string;
+    block: number;
+    challenges: string[];
+    chain: string;
+    offense: "equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation";
+    requests: string[];
+    schema: "network.xyo.s3.slash.index.key" & {
+        readonly __schema: true;
+    };
+    adjudication?: string | undefined;
+    outcome?: "confirmed" | "refuted" | "indeterminate" | "invalid" | undefined;
+};
+/** Converts a value to SlashIndexKeyRecord, throwing if invalid. */
+export declare const asSlashIndexKeyRecord: {
+    <T>(value: T): (T & {
+        accused: string;
+        block: number;
+        challenges: string[];
+        chain: string;
+        offense: "equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation";
+        requests: string[];
+        schema: "network.xyo.s3.slash.index.key" & {
+            readonly __schema: true;
+        };
+        adjudication?: string | undefined;
+        outcome?: "confirmed" | "refuted" | "indeterminate" | "invalid" | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        accused: string;
+        block: number;
+        challenges: string[];
+        chain: string;
+        offense: "equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation";
+        requests: string[];
+        schema: "network.xyo.s3.slash.index.key" & {
+            readonly __schema: true;
+        };
+        adjudication?: string | undefined;
+        outcome?: "confirmed" | "refuted" | "indeterminate" | "invalid" | undefined;
+    };
+};
+/** Builds a validated slash index head. */
+export declare function createSlashIndexHead(height: number, anchor?: number): SlashIndexHead;
+//# sourceMappingURL=slashIndex.d.ts.map

package/dist/neutral/modules/network-model/staticRest/layout/slashIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slashIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/slashIndex.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,kDAAkD;AAClD,eAAO,MAAM,oBAAoB;;CAAoD,CAAA;AACrF,oDAAoD;AACpD,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA;AAE9D,8EAA8E;AAC9E,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAIpC;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;;;;;;;iBAQ5B,CAAA;AAEF,oCAAoC;AACpC,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE9D,mEAAmE;AACnE,eAAO,MAAM,gBAAgB;;;;;;;CAAkC,CAAA;AAC/D,+DAA+D;AAC/D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;CAAsD,CAAA;AACnF,6CAA6C;AAC7C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;CAAsD,CAAA;AAEnF,+CAA+C;AAC/C,eAAO,MAAM,yBAAyB;;CAAmD,CAAA;AACzF,yDAAyD;AACzD,MAAM,MAAM,yBAAyB,GAAG,OAAO,yBAAyB,CAAA;AAExE;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBjC,CAAA;AAEF,6CAA6C;AAC7C,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAExE,wEAAwE;AACxE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;CAAuC,CAAA;AACzE,oEAAoE;AACpE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgE,CAAA;AAElG,2CAA2C;AAC3C,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,cAAc,CAIpF"}

package/dist/neutral/modules/network-model/staticRest/paths/index.d.ts

@@ -3,5 +3,6 @@ export * from './evmEventIndex.js';
 export * from './finalized.js';
 export * from './indexPaths.js';
 export * from './networkStakeRewardsIndex.js';
+export * from './slashIndex.js';
 export * from './transactionInclusionIndex.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/network-model/staticRest/paths/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/paths/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,+BAA+B,CAAA;AAC7C,cAAc,gCAAgC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/paths/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,+BAA+B,CAAA;AAC7C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gCAAgC,CAAA"}

package/dist/neutral/modules/network-model/staticRest/paths/slashIndex.d.ts

@@ -0,0 +1,31 @@
+import type { Hash } from '@ariestools/sdk';
+import type { XyoAddress } from '@xyo-network/sdk';
+import type { OffenseCode } from '../../../protocol-model/index.js';
+/** Path of the mutable slash-index head. */
+export declare function slashIndexHeadPath(): string;
+/** Path of the static slash-index manifest. */
+export declare function slashIndexManifestPath(): string;
+/** Path of one immutable recorded slash request. */
+export declare function slashIndexRequestPath(hash: Hash): string;
+/** Path of one immutable recorded slash commitment. */
+export declare function slashIndexCommitPath(hash: Hash): string;
+/** Path of one immutable recorded slash challenge. */
+export declare function slashIndexChallengePath(hash: Hash): string;
+/** Path of one immutable recorded slash adjudication. */
+export declare function slashIndexAdjudicationPath(hash: Hash): string;
+/**
+ * Path of the aggregate for one offense.
+ *
+ * Keyed by the canonical offense identity rather than by any report, so several reports of the
+ * same misconduct converge on one object instead of accumulating as separate accusations.
+ */
+export declare function slashIndexKeyPath(accused: XyoAddress, offense: OffenseCode, block: number): string;
+/** Path of one producer's offense history. */
+export declare function slashIndexAccusedPath(address: XyoAddress): string;
+/** Path of one reporter's claim history. */
+export declare function slashIndexClaimantPath(address: XyoAddress): string;
+/** Path of one published admission shadow report. */
+export declare function admissionShadowPath(height: number): string;
+/** Path of the mutable pointer to the newest admission shadow report. */
+export declare function admissionShadowHeadPath(): string;
+//# sourceMappingURL=slashIndex.d.ts.map

package/dist/neutral/modules/network-model/staticRest/paths/slashIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slashIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/paths/slashIndex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAIlD,4CAA4C;AAC5C,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED,+CAA+C;AAC/C,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C;AAED,oDAAoD;AACpD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAExD;AAED,uDAAuD;AACvD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAEvD;AAED,sDAAsD;AACtD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAE1D;AAED,yDAAyD;AACzD,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAE7D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAElG;AAED,8CAA8C;AAC9C,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAEjE;AAED,4CAA4C;AAC5C,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAElE;AAED,qDAAqD;AACrD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,yEAAyE;AACzE,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD"}

package/dist/neutral/modules/protocol-model/model/RuleActivation.d.ts

@@ -10,7 +10,7 @@ import type { OffenseCode } from './OffenseCode.js';
  * This list lives beside the offense codes rather than with the register, because in-block
  * validators have to name rules without depending on the register document's shape.
  */
-export declare const RuleIds: readonly ["intent-binding", "anchor-rules", "single-signer", "supersedes-field", "slash-payloads", "eligibility-admission", "attestation-admission", "certificate-execution", ...("equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable")[]];
+export declare const RuleIds: readonly ["intent-binding", "anchor-rules", "single-signer", "supersedes-field", "slash-payloads", "eligibility-admission", "attestation-admission", "certificate-execution", "fork-choice-v2", "bridge-value-ceiling", ...("equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable")[]];
 /** A rule whose activation height the register records. */
 export type RuleId = typeof RuleIds[number];
 /** The rule id gating whether reports naming an offense may be recorded. */

package/dist/neutral/modules/protocol-model/model/RuleActivation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RuleActivation.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/RuleActivation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAGnD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,OAAO,0nBAWV,CAAA;AAEV,2DAA2D;AAC3D,MAAM,MAAM,MAAM,GAAG,OAAO,OAAO,CAAC,MAAM,CAAC,CAAA;AAE3C,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAE7D;AAED,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAE9D;AAED;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAA;AAEjE;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,6CAA6C;IAC7C,WAAW,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAC5C,oDAAoD;IACpD,aAAa,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAC/C,qFAAqF;IACrF,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,mBAAmB,CAMrB;AAED,8CAA8C;AAC9C,wBAAgB,cAAc,CAAC,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAEpG;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAEtG"}
+{"version":3,"file":"RuleActivation.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/RuleActivation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAGnD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,OAAO,oqBAcV,CAAA;AAEV,2DAA2D;AAC3D,MAAM,MAAM,MAAM,GAAG,OAAO,OAAO,CAAC,MAAM,CAAC,CAAA;AAE3C,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAE7D;AAED,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAE9D;AAED;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAA;AAEjE;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,6CAA6C;IAC7C,WAAW,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAC5C,oDAAoD;IACpD,aAAa,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAC/C,qFAAqF;IACrF,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,mBAAmB,CAMrB;AAED,8CAA8C;AAC9C,wBAAgB,cAAc,CAAC,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAEpG;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAEtG"}