@substrat-run/engine-protocol 0.1.0

package/README.md

@@ -0,0 +1,60 @@
+# @substrat-run/engine-protocol
+
+Protocol engine for [Substrat](https://github.com/substrat-run/substrat) —
+checklists/protocols (egenkontroll, condition reports, inspection records) with the
+**sign → immutable** invariant: versioned templates, append-only responses, a
+verifiable content hash, and counter-signatures on frozen content.
+
+The engine owns only the invariants. Template *content* — which protocols exist and
+what they contain — is 100% vertical-owned, and an instance binds to any `EntityRef`
+(a work order today, anything tomorrow).
+
+## Invariants the engine owns
+
+1. **Sign freezes** — any write to a signed instance's responses fails.
+2. **Content hash** — SHA-256 over template content + latest responses at sign time,
+   verifiable against replayed state.
+3. **Counter-sign** — an *additional* signature on the same frozen content (the hash
+   is recomputed and must match; a principal never counter-signs their own signature).
+   Exactly one primary signature per instance.
+4. **Append-only responses** — an edit is a new row; history is audit material.
+5. **Version-pinned templates** — templates version immutably; an instance pins
+   `(key, version)` at instantiation forever.
+6. **Void, not delete** — a protocol is superseded, never mutated or removed.
+
+## Composing from a vertical
+
+Operations (`protocol/define-template`, `instantiate`, `fill`, `sign`, `countersign`,
+`void`, `get`, `list-for-entity`) are default bindings over exported in-scope
+functions your own operations can call — same transaction, your permission check:
+
+```ts
+import { instantiateProtocol, requireSigned, PROTOCOL_PERM } from '@substrat-run/engine-protocol';
+
+host.defineOperation('acme/start-inspection', async (ctx, input) => {
+  assertAllowed(await ctx.check(PROTOCOL_PERM.create));
+  return instantiateProtocol(ctx, {
+    templateKey: 'condition-report',
+    entity: input.bike, // any EntityRef — the vertical owns the vocabulary
+  });
+});
+```
+
+`requireSigned(ctx, entity, templateKey)` is the completion-guard building block: a
+vertical can refuse to close its own entity until the protocol on it is signed.
+
+Signing records the authenticated principal with an `in-app` method; connector-backed
+methods (BankID/Scrive-class) arrive later through the same operation shape with
+upgraded evidence. Signed/countersigned events carry the frozen answers in the
+payload — consumers never query back.
+
+## Related packages
+
+- [`@substrat-run/kernel`](https://npmjs.com/package/@substrat-run/kernel) — the
+  scope-host contract these operations run on
+- [`@substrat-run/contracts`](https://npmjs.com/package/@substrat-run/contracts) — the
+  Zod shapes (`EntityRef`, permission keys) this engine builds on
+
+## Status
+
+Pre-release (0.x): surfaces change without notice until the first vertical ships.

package/dist/index.d.ts

@@ -0,0 +1,400 @@
+import { z } from 'zod';
+import { type EntityRef } from '@substrat-run/contracts';
+import { type ModuleRegistration, type OperationContext } from '@substrat-run/kernel';
+export declare const PROTOCOL_PERM: {
+    create: string & z.BRAND<"PermissionKey">;
+    fill: string & z.BRAND<"PermissionKey">;
+    sign: string & z.BRAND<"PermissionKey">;
+    countersign: string & z.BRAND<"PermissionKey">;
+    read: string & z.BRAND<"PermissionKey">;
+    void: string & z.BRAND<"PermissionKey">;
+};
+export declare const protocolManifest: {
+    id: string & z.BRAND<"ModuleId">;
+    permissions: {
+        key: string & z.BRAND<"PermissionKey">;
+        description: string;
+    }[];
+    version: string;
+    kernelContract: string;
+    events: {
+        emits: {
+            type: string;
+            schemaVersion: number;
+        }[];
+        consumes: {
+            type: string;
+            schemaVersion: number;
+        }[];
+    };
+    migrations: {
+        journalDir: string;
+        compatibleFrom: string;
+    };
+    attachmentTargets: {
+        entityType: string;
+        readPermission: string & z.BRAND<"PermissionKey">;
+    }[];
+    entitlementKey: string;
+    entityRelations?: {
+        entityType: string;
+        parentType: string;
+    }[] | undefined;
+    api?: string | undefined;
+    searchables?: {
+        entityType: string;
+        fields: string[];
+    }[] | undefined;
+    ui?: {
+        routes?: {
+            path: string;
+            permission: string & z.BRAND<"PermissionKey">;
+            screen: string;
+        }[] | undefined;
+        nav?: {
+            permission: string & z.BRAND<"PermissionKey">;
+            label: string;
+            to: string;
+            icon?: string | undefined;
+        }[] | undefined;
+        entityViews?: {
+            entityType: string;
+            view: string;
+        }[] | undefined;
+        widgets?: {
+            permission: string & z.BRAND<"PermissionKey">;
+            slot: string;
+            component: string;
+        }[] | undefined;
+        settingsPanels?: {
+            permission: string & z.BRAND<"PermissionKey">;
+            label: string;
+            component: string;
+        }[] | undefined;
+    } | undefined;
+};
+export declare const protocolMigrations: {
+    version: string;
+    sql: string;
+}[];
+export declare const protocolItem: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    type: z.ZodEnum<["check", "value", "text"]>;
+    unit: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    label: string;
+    type: "value" | "check" | "text";
+    unit?: string | undefined;
+}, {
+    key: string;
+    label: string;
+    type: "value" | "check" | "text";
+    unit?: string | undefined;
+}>;
+export type ProtocolItem = z.infer<typeof protocolItem>;
+export declare const protocolTemplateContent: z.ZodObject<{
+    sections: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        items: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            type: z.ZodEnum<["check", "value", "text"]>;
+            unit: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            key: string;
+            label: string;
+            type: "value" | "check" | "text";
+            unit?: string | undefined;
+        }, {
+            key: string;
+            label: string;
+            type: "value" | "check" | "text";
+            unit?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        items: {
+            key: string;
+            label: string;
+            type: "value" | "check" | "text";
+            unit?: string | undefined;
+        }[];
+    }, {
+        title: string;
+        items: {
+            key: string;
+            label: string;
+            type: "value" | "check" | "text";
+            unit?: string | undefined;
+        }[];
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    sections: {
+        title: string;
+        items: {
+            key: string;
+            label: string;
+            type: "value" | "check" | "text";
+            unit?: string | undefined;
+        }[];
+    }[];
+}, {
+    sections: {
+        title: string;
+        items: {
+            key: string;
+            label: string;
+            type: "value" | "check" | "text";
+            unit?: string | undefined;
+        }[];
+    }[];
+}>;
+export type ProtocolTemplateContent = z.infer<typeof protocolTemplateContent>;
+export interface ProtocolTemplateRow {
+    id: string;
+    key: string;
+    version: number;
+    title: string;
+    content_json: string;
+    created_at: string;
+}
+export interface ProtocolInstanceRow {
+    id: string;
+    template_key: string;
+    template_version: number;
+    entity_type: string;
+    entity_id: string;
+    status: 'open' | 'signed' | 'voided';
+    created_by: string;
+    created_at: string;
+    voided_by: string | null;
+    voided_reason: string | null;
+    voided_at: string | null;
+}
+export interface ProtocolResponseRow {
+    id: string;
+    instance_id: string;
+    item_key: string;
+    value_json: string;
+    note: string | null;
+    responded_by: string;
+    responded_at: string;
+}
+export interface ProtocolSignatureRow {
+    id: string;
+    instance_id: string;
+    signed_by: string;
+    kind: 'primary' | 'counter';
+    method: string;
+    content_hash: string;
+    evidence_ref: string | null;
+    signed_at: string;
+}
+export declare function protocolContentHash(template: Pick<ProtocolTemplateRow, 'key' | 'version' | 'content_json'>, latest: Record<string, ProtocolResponseRow>): Promise<string>;
+export declare function requireSigned(ctx: OperationContext, entity: EntityRef, templateKey: string): void;
+export declare const defineTemplateInput: z.ZodObject<{
+    key: z.ZodString;
+    title: z.ZodString;
+    content: z.ZodObject<{
+        sections: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            items: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                label: z.ZodString;
+                type: z.ZodEnum<["check", "value", "text"]>;
+                unit: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                key: string;
+                label: string;
+                type: "value" | "check" | "text";
+                unit?: string | undefined;
+            }, {
+                key: string;
+                label: string;
+                type: "value" | "check" | "text";
+                unit?: string | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            title: string;
+            items: {
+                key: string;
+                label: string;
+                type: "value" | "check" | "text";
+                unit?: string | undefined;
+            }[];
+        }, {
+            title: string;
+            items: {
+                key: string;
+                label: string;
+                type: "value" | "check" | "text";
+                unit?: string | undefined;
+            }[];
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        sections: {
+            title: string;
+            items: {
+                key: string;
+                label: string;
+                type: "value" | "check" | "text";
+                unit?: string | undefined;
+            }[];
+        }[];
+    }, {
+        sections: {
+            title: string;
+            items: {
+                key: string;
+                label: string;
+                type: "value" | "check" | "text";
+                unit?: string | undefined;
+            }[];
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    title: string;
+    content: {
+        sections: {
+            title: string;
+            items: {
+                key: string;
+                label: string;
+                type: "value" | "check" | "text";
+                unit?: string | undefined;
+            }[];
+        }[];
+    };
+}, {
+    key: string;
+    title: string;
+    content: {
+        sections: {
+            title: string;
+            items: {
+                key: string;
+                label: string;
+                type: "value" | "check" | "text";
+                unit?: string | undefined;
+            }[];
+        }[];
+    };
+}>;
+export type DefineTemplateInput = z.infer<typeof defineTemplateInput>;
+/**
+ * Templates version immutably: same key + new content = next version, the
+ * old row is never touched. Editing a template never rewrites what a signed
+ * document referred to.
+ */
+export declare function defineTemplate(ctx: OperationContext, rawInput: DefineTemplateInput): ProtocolTemplateRow;
+/** Latest version per key — the instantiation picker's list. */
+export declare function listTemplates(ctx: OperationContext): ProtocolTemplateRow[];
+export declare const instantiateProtocolInput: z.ZodObject<{
+    templateKey: z.ZodString;
+    entity: z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        entityType: string;
+        entityId: string;
+    }, {
+        entityType: string;
+        entityId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    templateKey: string;
+    entity: {
+        entityType: string;
+        entityId: string;
+    };
+}, {
+    templateKey: string;
+    entity: {
+        entityType: string;
+        entityId: string;
+    };
+}>;
+export type InstantiateProtocolInput = z.infer<typeof instantiateProtocolInput>;
+/**
+ * Pins the latest template version at instantiation — forever (invariant 5).
+ * One OPEN instance per (template, entity). Which entity types may carry
+ * which protocols, and when, is vertical policy — enforced by the caller.
+ */
+export declare function instantiateProtocol(ctx: OperationContext, rawInput: InstantiateProtocolInput): ProtocolInstanceRow;
+export declare const fillProtocolInput: z.ZodObject<{
+    instanceId: z.ZodString;
+    itemKey: z.ZodString;
+    value: z.ZodUnion<[z.ZodBoolean, z.ZodString]>;
+    note: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    value: string | boolean;
+    instanceId: string;
+    itemKey: string;
+    note?: string | undefined;
+}, {
+    value: string | boolean;
+    instanceId: string;
+    itemKey: string;
+    note?: string | undefined;
+}>;
+export type FillProtocolInput = z.infer<typeof fillProtocolInput>;
+export declare function fillProtocol(ctx: OperationContext, rawInput: FillProtocolInput): ProtocolResponseRow;
+export interface SignResult {
+    instance: ProtocolInstanceRow;
+    signature: ProtocolSignatureRow;
+}
+/**
+ * In-app sign (engine-protocol.md §5): the authenticated principal signs;
+ * integrity comes from the hash + immutability + the spine event. Connector
+ * methods (bankid/scrive) arrive later through the SAME operation shape with
+ * upgraded evidence. Exactly ONE primary signature per instance — enforced by
+ * the open → signed transition.
+ */
+export declare function signProtocol(ctx: OperationContext, input: {
+    instanceId: string;
+}): Promise<SignResult>;
+/**
+ * Counter-sign (invariant 3): a SECOND signature on the SAME frozen content —
+ * the customer at pickup. Requires a signed instance; the content hash is
+ * recomputed and must equal the primary signature's hash (frozen content,
+ * verified, never assumed). One counter-signature per principal; a principal
+ * never counter-signs what they primary-signed.
+ */
+export declare function countersignProtocol(ctx: OperationContext, input: {
+    instanceId: string;
+}): Promise<SignResult>;
+/** Voiding, not deleting: a superseded protocol keeps its rows forever. */
+export declare function voidProtocol(ctx: OperationContext, input: {
+    instanceId: string;
+    reason: string;
+}): ProtocolInstanceRow;
+export interface ProtocolDetail {
+    instance: ProtocolInstanceRow;
+    template: {
+        key: string;
+        version: number;
+        title: string;
+        content: ProtocolTemplateContent;
+    };
+    responses: ProtocolResponseRow[];
+    latest: Record<string, ProtocolResponseRow>;
+    signature: ProtocolSignatureRow | null;
+    signatures: ProtocolSignatureRow[];
+}
+export declare function getProtocol(ctx: OperationContext, instanceId: string): ProtocolDetail;
+export interface ProtocolSummary {
+    instance: ProtocolInstanceRow;
+    title: string;
+    answered: number;
+    total: number;
+    signedBy: string | null;
+    signedAt: string | null;
+    countersignedBy: string | null;
+    countersignedAt: string | null;
+}
+export declare function listProtocolsForEntity(ctx: OperationContext, entity: EntityRef): ProtocolSummary[];
+export declare const protocolModule: ModuleRegistration;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}