@blokjs/shared 2.0.1 → 2.2.0

package/dist/EnforcementContracts.js

@@ -0,0 +1,17 @@
+/**
+ * H1-02 contracts shared by authoring, the runner, and control-plane adapters.
+ *
+ * These are deliberately data-only. A model can return data that resembles a
+ * trusted record, but the runner decides whether the producing step is allowed
+ * to establish trusted provenance.
+ */
+export const ENFORCEMENT_CONTRACT_VERSION = "1";
+export class EnforcementViolationError extends Error {
+    reasonCode;
+    code = "ENFORCEMENT_REJECTED";
+    constructor(reasonCode, message) {
+        super(message);
+        this.reasonCode = reasonCode;
+        this.name = "EnforcementViolationError";
+    }
+}

package/dist/EnforcementProfileContracts.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+/** Version of the language-neutral enforcement profile contract. */
+export declare const ENFORCEMENT_PROFILE_CONTRACT_VERSION: "1";
+export declare const ENFORCEMENT_PROFILES: readonly ["advisory", "guided", "strict"];
+export type EnforcementProfile = (typeof ENFORCEMENT_PROFILES)[number];
+export interface EnforcementProfileSemantics {
+    readonly deviations: "record" | "authorized-override" | "reject";
+    readonly transitions: "advisory" | "enforced";
+    readonly inRunOverride: "allowed" | "forbidden";
+}
+/** Machine-readable semantics; keep this table in sync with ADR 0002. */
+export declare const ENFORCEMENT_PROFILE_SEMANTICS: Readonly<Record<EnforcementProfile, EnforcementProfileSemantics>>;
+export declare const EnforcementProfileSchema: z.ZodEnum<["advisory", "guided", "strict"]>;
+export interface EnforcementProfileContract {
+    readonly version: typeof ENFORCEMENT_PROFILE_CONTRACT_VERSION;
+    readonly profile: EnforcementProfile;
+}
+export declare const EnforcementProfileContractSchema: z.ZodObject<{
+    version: z.ZodLiteral<"1">;
+    profile: z.ZodEnum<["advisory", "guided", "strict"]>;
+}, "strip", z.ZodTypeAny, {
+    version: "1";
+    profile: "strict" | "advisory" | "guided";
+}, {
+    version: "1";
+    profile: "strict" | "advisory" | "guided";
+}>;
+export declare class EnforcementProfileContractError extends Error {
+    readonly issues: readonly string[];
+    constructor(issues: readonly string[]);
+}
+export declare function parseEnforcementProfile(value: unknown): EnforcementProfile;
+export declare function parseEnforcementProfileContract(value: unknown): EnforcementProfileContract;
+/** Return the immutable, machine-readable behavior for one profile. */
+export declare function enforcementProfileSemantics(value: unknown): EnforcementProfileSemantics;
+export declare function serializeEnforcementProfileContract(value: unknown): string;

package/dist/EnforcementProfileContracts.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+/** Version of the language-neutral enforcement profile contract. */
+export const ENFORCEMENT_PROFILE_CONTRACT_VERSION = "1";
+export const ENFORCEMENT_PROFILES = ["advisory", "guided", "strict"];
+/** Machine-readable semantics; keep this table in sync with ADR 0002. */
+export const ENFORCEMENT_PROFILE_SEMANTICS = {
+    advisory: {
+        deviations: "record",
+        transitions: "advisory",
+        inRunOverride: "allowed",
+    },
+    guided: {
+        deviations: "authorized-override",
+        transitions: "enforced",
+        inRunOverride: "allowed",
+    },
+    strict: {
+        deviations: "reject",
+        transitions: "enforced",
+        inRunOverride: "forbidden",
+    },
+};
+export const EnforcementProfileSchema = z.enum(ENFORCEMENT_PROFILES);
+export const EnforcementProfileContractSchema = z.object({
+    version: z.literal(ENFORCEMENT_PROFILE_CONTRACT_VERSION),
+    profile: EnforcementProfileSchema,
+});
+export class EnforcementProfileContractError extends Error {
+    issues;
+    constructor(issues) {
+        super(`Invalid enforcement profile contract: ${issues.join("; ")}`);
+        this.name = "EnforcementProfileContractError";
+        this.issues = [...issues];
+    }
+}
+function parseSchema(schema, value, label) {
+    const result = schema.safeParse(value);
+    if (!result.success) {
+        throw new EnforcementProfileContractError(result.error.issues.map((issue) => `${label}${issue.path.length > 0 ? `.${issue.path.join(".")}` : ""} ${issue.message}`));
+    }
+    return result.data;
+}
+export function parseEnforcementProfile(value) {
+    return parseSchema(EnforcementProfileSchema, value, "enforcement profile");
+}
+export function parseEnforcementProfileContract(value) {
+    return parseSchema(EnforcementProfileContractSchema, value, "enforcement profile contract");
+}
+/** Return the immutable, machine-readable behavior for one profile. */
+export function enforcementProfileSemantics(value) {
+    return ENFORCEMENT_PROFILE_SEMANTICS[parseEnforcementProfile(value)];
+}
+export function serializeEnforcementProfileContract(value) {
+    return JSON.stringify(parseEnforcementProfileContract(value));
+}