@substrat-run/contract-tests 0.116.0 → 0.117.0

package/dist/index.js

@@ -2,6 +2,8 @@ export { scopeHostContractSuite } from './scope-host-suite.js';
 export { permissionContractSuite } from './permission-suite.js';
 export { atomicContractSuite } from './atomic-suite.js';
 export { impersonationContractSuite } from './impersonation-suite.js';
+export { capabilityContractSuite } from './capability-suite.js';
+export { capabilityExpiryContractSuite } from './capability-expiry-suite.js';
 export { searchContractSuite } from './search-suite.js';
 export { entityVersionContractSuite } from './entity-version-suite.js';
 export { timelineContractSuite } from './timeline-suite.js';
@@ -10,6 +12,7 @@ export { idempotencyContractSuite } from './idempotency-suite.js';
 export { listContractSuite } from './list-suite.js';
 export { scheduleContractSuite } from './schedule-suite.js';
 export { jobRunContractSuite } from './job-run-suite.js';
+export { systemSwitchContractSuite } from './system-switch-suite.js';
 export { inputParseContractSuite } from './input-parse-suite.js';
 export { spineGuardContractSuite } from './spine-guard-suite.js';
 export { grantExpiryContractSuite } from './grant-expiry-suite.js';
@@ -17,6 +20,6 @@ export { facetRecencyContractSuite } from './facet-recency-suite.js';
 export { entityCheckConformanceSuite, planEntityCheckCoverage } from './entity-check-suite.js';
 export { nodeOnlySuite, declaredNodeOnlySuite } from './node-only-suite.js';
 export { declareEntityChecks, declareNodeOnly, assertNodeOnly } from './conformance.js';
-export { atomicMod, billedMod, brokenMod, connectorMod, contractTestBareOps, contractTestInitialModules, contractTestModules, liveMod, liveModManifest, permMod, scheduleMod, jobsMod, testMod, freshnessMod, searchMod, searchModManifest, listMod, listModManifest, parseMod, parseModManifest, } from './modules.js';
+export { atomicMod, billedMod, brokenMod, connectorMod, contractTestBareOps, contractTestInitialModules, contractTestModules, liveMod, liveModManifest, permMod, capMod, capModManifest, scheduleMod, jobsMod, testMod, freshnessMod, searchMod, searchModManifest, listMod, listModManifest, parseMod, parseModManifest, } from './modules.js';
 export { connectorCalls, connectorTestFetch, resetConnectorCalls, } from './connector-fixture.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAE,yBAAyB,EAA4B,MAAM,0BAA0B,CAAC;AAE/F,OAAO,EAAE,2BAA2B,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAE/F,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAE5E,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAOxF,OAAO,EACL,SAAS,EACT,SAAS,EACT,SAAS,EACT,YAAY,EACZ,mBAAmB,EACnB,0BAA0B,EAC1B,mBAAmB,EACnB,OAAO,EACP,eAAe,EACf,OAAO,EACP,WAAW,EACX,OAAO,EACP,OAAO,EACP,YAAY,EACZ,SAAS,EACT,iBAAiB,EACjB,OAAO,EACP,eAAe,EACf,QAAQ,EACR,gBAAgB,GACjB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,mBAAmB,GAEpB,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,6BAA6B,EAAE,MAAM,8BAA8B,CAAC;AAE7E,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAE,yBAAyB,EAA4B,MAAM,0BAA0B,CAAC;AAE/F,OAAO,EAAE,2BAA2B,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAE/F,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAE5E,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAOxF,OAAO,EACL,SAAS,EACT,SAAS,EACT,SAAS,EACT,YAAY,EACZ,mBAAmB,EACnB,0BAA0B,EAC1B,mBAAmB,EACnB,OAAO,EACP,eAAe,EACf,OAAO,EACP,MAAM,EACN,cAAc,EACd,WAAW,EACX,OAAO,EACP,OAAO,EACP,YAAY,EACZ,SAAS,EACT,iBAAiB,EACjB,OAAO,EACP,eAAe,EACf,QAAQ,EACR,gBAAgB,GACjB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,mBAAmB,GAEpB,MAAM,wBAAwB,CAAC"}

package/dist/modules.d.ts

@@ -2466,6 +2466,132 @@ export declare const idempotencyModManifest: {
     } | undefined;
 };
 export declare const idempotencyMod: ModuleRegistration;
+/**
+ * The fixture for the capability suite: a folder tree (`doc` → `folder`, `folder` →
+ * `folder`), three keys, and operations shaped the way a document vertical's would be —
+ * a read and a write that check ONE entity, so what a capability can reach is decided by
+ * the checker's walk and nothing else.
+ *
+ * The minting operations are deliberately UNGUARDED, like `perm/share`: the guardrails
+ * under test live inside `ctx.capabilities`, and an operation-level check in front of
+ * them would only prove the check.
+ */
+export declare const capModManifest: {
+    id: string & z.$brand<"ModuleId">;
+    version: string;
+    kernelContract: string;
+    permissions: {
+        key: string & z.$brand<"PermissionKey">;
+        description: 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">;
+        writePermission?: (string & z.$brand<"PermissionKey">) | undefined;
+    }[];
+    liveTargets?: {
+        entityType: string;
+        readPermission: string & z.$brand<"PermissionKey">;
+    }[] | undefined;
+    entityRelations?: {
+        entityType: string;
+        parentType: string;
+    }[] | undefined;
+    guards?: {
+        before: string;
+        predicate: string;
+        config: Record<string, unknown>;
+    }[] | undefined;
+    schedules?: {
+        operation: string;
+        cadence: {
+            everyMinutes: number;
+        };
+        input?: Record<string, unknown> | undefined;
+        permissions: (string & z.$brand<"PermissionKey">)[];
+    }[] | undefined;
+    freshness?: {
+        eventType: string;
+        within: {
+            hours: number;
+        };
+    }[] | undefined;
+    withdraws?: string[] | undefined;
+    entitlementKey: string;
+    envSpec?: {
+        key: string;
+        label?: string | undefined;
+        description: string;
+        placeholder?: string | undefined;
+        required: boolean;
+        secret: boolean;
+        default?: string | undefined;
+        group?: string | undefined;
+    }[] | undefined;
+    ownerGrants?: (string & z.$brand<"PermissionKey">)[] | undefined;
+    entitlements?: string[] | undefined;
+    provides?: string[] | undefined;
+    requires?: string[] | undefined;
+    api?: string | undefined;
+    searchables?: {
+        entityType: string;
+        fields: string[];
+        table?: string | undefined;
+        idColumn?: string | undefined;
+        tokenizer?: "prefix" | "substring" | undefined;
+    }[] | undefined;
+    lists?: {
+        entityType: string;
+        sortable: string[];
+        filterable?: string[] | undefined;
+        table?: string | undefined;
+        idColumn?: string | undefined;
+    }[] | undefined;
+    ui?: {
+        routes?: {
+            path: string;
+            screen: string;
+            permission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+        nav?: {
+            label: string;
+            icon?: string | undefined;
+            to: string;
+            permission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+        entityViews?: {
+            entityType: string;
+            view: string;
+        }[] | undefined;
+        widgets?: {
+            slot: string;
+            component: string;
+            permission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+        settingsPanels?: {
+            label: string;
+            component: string;
+            permission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+    } | undefined;
+};
+/** Every channel through which a module could persist its own minted secret by accident. */
+export declare const CAP_LEAK_CHANNELS: readonly ['emit', 'key', 'entity', 'kind', 'intent', 'sql', 'bytes'];
+export declare const capMod: ModuleRegistration;
 export declare const contractTestModules: ModuleRegistration[];
 /**
  * A module for the live-read fan-out, with two entity types that differ in exactly

package/dist/modules.d.ts.map

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

package/dist/modules.js

@@ -286,6 +286,10 @@ export const permModManifest = moduleManifest.parse({
     permissions: [
         { key: 'perm:use', description: 'use the thing' },
         { key: 'perm:read', description: 'read the thing' },
+        // #1655: exactly PERMISSION_KEY_MAX_LENGTH (41) bytes, the longest key a manifest
+        // accepts — so both adapters run a real check of it, and the Durable-Object one
+        // builds `granted:<key>%` at the 50-byte LIKE limit it enforces and node does not.
+        { key: 'perm:long-key-at-the-like-pattern-limit01', description: 'the longest key' },
     ],
     events: {
         // #473: the attachment surface emits these on upload/remove; declaring them keeps the
@@ -293,8 +297,11 @@ export const permModManifest = moduleManifest.parse({
         emits: [
             { type: 'attachment.added', schemaVersion: 1 },
             { type: 'attachment.removed', schemaVersion: 1 },
+            { type: 'perm.check-requested', schemaVersion: 1 },
         ],
-        consumes: [],
+        // #1642: a consumer runs under a SYSTEM actor, whose check allows without asking
+        // the checker — the one path a malformed key could slip through unrefused.
+        consumes: [{ type: 'perm.check-requested', schemaVersion: 1 }],
     },
     migrations: { journalDir: './migrations', compatibleFrom: '1.0.0' },
     // #473: an attachment target on `item`, gated read=perm:read / write=perm:use — reusing
@@ -604,6 +611,89 @@ const authorizedReadOp = async (ctx, input) => {
     return ctx.sql.query('SELECT COUNT(*) AS n FROM testmod_items')[0].n;
 };
 const readOutboxOp = (ctx) => ctx.sql.query('SELECT id, type, authorization, impersonation, operation FROM _substrat_outbox ORDER BY id');
+// #1642: a check whose throw is CAUGHT AND IGNORED — the careless caller a
+// fail-closed refusal has to survive. It reports what it was handed back, then emits
+// anyway, so a test can read what the event's K-34 `authorization` says passed.
+const swallowedCheckOp = async (ctx, input) => {
+    let allowed = false;
+    let threw = null;
+    try {
+        allowed = (await ctx.check(input.permission)).allowed;
+    }
+    catch (err) {
+        threw = err instanceof Error ? err.message : String(err);
+    }
+    ctx.emit({
+        type: 'perm.acted',
+        schemaVersion: 1,
+        entity: { entityType: 'test-thing', entityId: 'swallowed' },
+        piiClass: 'none',
+        payload: {},
+    });
+    return { allowed, threw };
+};
+// #1642: hand a key to the system-actor path. The consumer below does the check.
+const requestCheckOp = (ctx, input) => {
+    ctx.emit({
+        type: 'perm.check-requested',
+        schemaVersion: 1,
+        entity: { entityType: 'test-thing', entityId: ulid() },
+        piiClass: 'none',
+        payload: input,
+    });
+};
+const CHECK_LOG_DDL = `CREATE TABLE IF NOT EXISTS perm_check_log (
+  event_id TEXT PRIMARY KEY, permission TEXT NOT NULL, allowed INTEGER NOT NULL,
+  threw TEXT, grant_threw TEXT)`;
+/**
+ * Runs as the system actor, whose `ctx.check` is allowed by construction. With
+ * `swallow` it catches the check's throw — and a `ctx.grant` of the same key, which
+ * the system actor would otherwise write straight into `_substrat_tuples` — and logs
+ * the outcome; without it, the throw dead-letters the event.
+ */
+const checkRequestedConsumer = async (ctx, event) => {
+    const p = event.payload;
+    const permission = p.permission; // the cast under test
+    if (!p.swallow) {
+        assertAllowed(await ctx.check(permission));
+        ctx.sql.exec(CHECK_LOG_DDL);
+        ctx.sql.exec('INSERT INTO perm_check_log (event_id, permission, allowed) VALUES (?, ?, 1)', [
+            event.id,
+            p.permission,
+        ]);
+        return;
+    }
+    let allowed = false;
+    let threw = null;
+    let grantThrew = null;
+    try {
+        allowed = (await ctx.check(permission)).allowed;
+    }
+    catch (err) {
+        threw = err instanceof Error ? err.message : String(err);
+    }
+    try {
+        await ctx.grant(principalId.parse(p.principal), permission, {
+            entityType: 'item',
+            entityId: 'check-requested',
+        });
+    }
+    catch (err) {
+        grantThrew = err instanceof Error ? err.message : String(err);
+    }
+    ctx.sql.exec(CHECK_LOG_DDL);
+    ctx.sql.exec('INSERT INTO perm_check_log (event_id, permission, allowed, threw, grant_threw) VALUES (?, ?, ?, ?, ?)', [event.id, p.permission, allowed ? 1 : 0, threw, grantThrew]);
+};
+const readCheckLogOp = (ctx) => {
+    ctx.sql.exec(CHECK_LOG_DDL);
+    return {
+        log: ctx.sql.query('SELECT event_id, permission, allowed, threw, grant_threw FROM perm_check_log ORDER BY event_id'),
+        deliveries: ctx.sql.query(`SELECT d.event_id, d.error, json_extract(o.payload, '$.permission') AS permission
+         FROM _substrat_deliveries d JOIN _substrat_outbox o ON o.id = d.event_id
+        WHERE o.type = 'perm.check-requested' ORDER BY d.event_id`),
+        tuples: ctx.sql.query(`SELECT subject, relation, object FROM _substrat_tuples WHERE object = 'item:check-requested'`),
+    };
+};
 const readDenialsOp = (ctx) => ctx.sql.query(`SELECT actor, permission, tenant_id, scope_id, operation, impersonation, invocation_id
        FROM _substrat_denials ORDER BY id`);
 // -- K-42 fixtures (#868) ----------------------------------------------------
@@ -1003,6 +1093,10 @@ export const permMod = {
         'perm/authorized-read': authorizedReadOp,
         'perm/read-outbox': readOutboxOp,
         'perm/read-denials': readDenialsOp,
+        // #1642
+        'perm/swallowed-check': swallowedCheckOp,
+        'perm/request-check': requestCheckOp,
+        'perm/read-check-log': readCheckLogOp,
         // K-42 (#868)
         'perm/write-note': noteWriteOp,
         'perm/read-notes': noteReadOp,
@@ -1041,6 +1135,9 @@ export const permMod = {
             return { revoked: true };
         }),
     },
+    consumers: {
+        'perm.check-requested': checkRequestedConsumer,
+    },
 };
 export const connectorModManifest = moduleManifest.parse({
     id: '@test/connector',
@@ -1583,6 +1680,178 @@ export const idempotencyMod = {
     operationConcurrency: operationConcurrencyOf(idempotencyDeclaration),
     operationIdempotencyOptOuts: operationIdempotencyOptOutsOf(idempotencyDeclaration),
 };
+// -- capabilities (#1672) ------------------------------------------------------
+/**
+ * The fixture for the capability suite: a folder tree (`doc` → `folder`, `folder` →
+ * `folder`), three keys, and operations shaped the way a document vertical's would be —
+ * a read and a write that check ONE entity, so what a capability can reach is decided by
+ * the checker's walk and nothing else.
+ *
+ * The minting operations are deliberately UNGUARDED, like `perm/share`: the guardrails
+ * under test live inside `ctx.capabilities`, and an operation-level check in front of
+ * them would only prove the check.
+ */
+export const capModManifest = moduleManifest.parse({
+    id: '@cap/mod',
+    version: '1.0.0',
+    kernelContract: '^0.0.1',
+    permissions: [
+        { key: 'cap:read', description: 'read a folder or a document' },
+        { key: 'cap:write', description: 'comment on a document' },
+        { key: 'cap:admin', description: 'arrange the folder tree' },
+    ],
+    events: {
+        emits: [
+            { type: 'cap.commented', schemaVersion: 1 },
+            { type: 'cap.mint-requested', schemaVersion: 1 },
+        ],
+        consumes: [{ type: 'cap.mint-requested', schemaVersion: 1 }],
+    },
+    migrations: { journalDir: './migrations', compatibleFrom: '1.0.0' },
+    attachmentTargets: [],
+    entityRelations: [
+        { entityType: 'doc', parentType: 'folder' },
+        { entityType: 'folder', parentType: 'folder' },
+    ],
+    entitlementKey: 'cap',
+});
+const CAP_READ = permissionKey.parse('cap:read');
+const CAP_WRITE = permissionKey.parse('cap:write');
+/** Every channel through which a module could persist its own minted secret by accident. */
+export const CAP_LEAK_CHANNELS = ['emit', 'key', 'entity', 'kind', 'intent', 'sql', 'bytes'];
+export const capMod = {
+    manifest: capModManifest,
+    migrations: [
+        { version: '0001-init', sql: 'CREATE TABLE cap_notes (id TEXT PRIMARY KEY, body TEXT NOT NULL)' },
+    ],
+    operations: {
+        'cap/link': linkOp,
+        'cap/share': ((ctx, input) => ctx.capabilities.mint(input)),
+        // The link a vertical would hand back — the secret spliced into a URL fragment, so the
+        // idempotency redaction has to find it INSIDE a string, not only as a whole value.
+        'cap/share-link': (async (ctx, input) => {
+            const minted = await ctx.capabilities.mint(input);
+            return { id: minted.id, link: `https://docs.example/#share=${minted.secret}` };
+        }),
+        // A module that mints and then writes something through ONE persisting channel. With
+        // `leak: true` what it writes is the secret — each channel an accident could take, and
+        // each must be refused, the refusal rolling the mint back with it. With `leak: false` it
+        // writes a harmless value through the very same channel: the clean twin, which must go
+        // through, so a guard that refused the channel outright would fail it.
+        'cap/share-and-leak': (async (ctx, input) => {
+            const i = input;
+            const { via, leak = true, ...spec } = i;
+            const minted = await ctx.capabilities.mint(spec);
+            const value = leak ? minted.secret : `harmless-${minted.id}`;
+            const note = (payload, entity = spec.entity) => ctx.emit({ type: 'cap.commented', schemaVersion: 1, entity, piiClass: 'none', payload });
+            switch (via) {
+                case 'emit': // a payload value, spliced into a string
+                    note({ note: `share it: ${value}` });
+                    break;
+                case 'key': // an object KEY — JSON persists property names too
+                    note({ links: { [value]: true } });
+                    break;
+                case 'entity': // the event's entity id — persisted in its own outbox column
+                    note({ note: 'filed under the link' }, { entityType: 'doc', entityId: value });
+                    break;
+                case 'kind': // a platform intent's kind — persisted as surely as its payload
+                    ctx.requestPlatform({ kind: value, payload: {} });
+                    break;
+                case 'intent': // a platform intent's payload
+                    ctx.requestPlatform({ kind: 'cap-note', payload: { body: value } });
+                    break;
+                case 'sql': // a text SQL parameter
+                    ctx.sql.exec('INSERT INTO cap_notes (id, body) VALUES (?, ?)', [ulid(), value]);
+                    break;
+                case 'bytes': // a BYTE SQL parameter — stored as a BLOB, still the plaintext
+                    ctx.sql.exec('INSERT INTO cap_notes (id, body) VALUES (?, ?)', [
+                        ulid(),
+                        new TextEncoder().encode(value),
+                    ]);
+                    break;
+            }
+            return { id: minted.id };
+        }),
+        'cap/unshare': (async (ctx, input) => {
+            await ctx.capabilities.revoke(input.id);
+            return { revoked: true };
+        }),
+        'cap/list': ((ctx, input) => ctx.capabilities.list(input)),
+        // A read of ONE entity — the proof comes back so a test can see what authorized it.
+        'cap/read': (async (ctx, input) => {
+            const entity = input.entity;
+            const decision = await ctx.check(CAP_READ, entity);
+            assertAllowed(decision);
+            return { read: entity, proof: decision.proof };
+        }),
+        // A node-level read: a capability holds no node-level authority, so this refuses it.
+        'cap/read-all': (async (ctx) => {
+            assertAllowed(await ctx.check(CAP_READ));
+            return { all: true };
+        }),
+        // A write of ONE entity, which emits — K-34 authorization and the actor land on it.
+        'cap/comment': (async (ctx, input) => {
+            const i = input;
+            assertAllowed(await ctx.check(CAP_WRITE, i.doc));
+            ctx.emit({
+                type: 'cap.commented',
+                schemaVersion: 1,
+                entity: i.doc,
+                piiClass: 'none',
+                payload: { body: i.body },
+            });
+            return { commented: true };
+        }),
+        'cap/whoami': whoAmIOp,
+        // Asks the CONSUMER below to mint. A consumer runs under an override actor whose
+        // checks allow unconditionally, so "the minter holds every key" would be vacuous
+        // there — the mint must be refused outright, whatever the check would have said.
+        'cap/request-mint': (async (ctx, input) => {
+            ctx.emit({
+                type: 'cap.mint-requested',
+                schemaVersion: 1,
+                entity: input.entity,
+                piiClass: 'none',
+                payload: { entity: input.entity },
+            });
+            return { requested: true };
+        }),
+        'cap/notes': ((ctx) => ctx.sql.query('SELECT id, body FROM cap_notes ORDER BY id')),
+        'cap/outbox': ((ctx) => ctx.sql.query('SELECT id, type, occurred_at, actor, authorization, operation, entity_type, entity_id, payload FROM _substrat_outbox ORDER BY id')),
+        'cap/denials': readDenialsOp,
+        // The session table's size — what the bounded prune is measured by.
+        'cap/session-count': ((ctx) => ctx.sql.query('SELECT COUNT(*) AS n FROM _substrat_capability_sessions')[0]?.n ??
+            0),
+        // Every table in this scope, every row, as text — what "the secret appears in no stored
+        // row" is checked against. Read through module-facing `ctx.sql` on purpose: this is
+        // what a vertical (or a dump of the scope) can see.
+        'cap/dump': ((ctx) => {
+            const tables = ctx.sql.query("SELECT name FROM sqlite_master WHERE type = 'table' " +
+                "AND substr(name, 1, 4) <> '_cf_' AND substr(name, 1, 7) <> 'sqlite_'");
+            const out = {};
+            for (const { name } of tables) {
+                out[name] = JSON.stringify(ctx.sql.query(`SELECT * FROM "${name}"`));
+            }
+            return out;
+        }),
+    },
+    consumers: {
+        // Records what the mint answered rather than letting the delivery fail, so the test
+        // reads an outcome instead of inferring one from a dead letter.
+        'cap.mint-requested': (async (ctx, event) => {
+            const entity = event.payload.entity;
+            let outcome;
+            try {
+                const minted = await ctx.capabilities.mint({ entity, permissions: [CAP_READ] });
+                outcome = `minted ${minted.id}`;
+            }
+            catch (err) {
+                outcome = `refused ${err.code ?? err.message}`;
+            }
+            ctx.sql.exec('INSERT INTO cap_notes (id, body) VALUES (?, ?)', [event.id, outcome]);
+        }),
+    },
+};
 export const contractTestModules = [
     ...contractTestInitialModules,
     lateMod,
@@ -1603,6 +1872,9 @@ export const contractTestModules = [
     parseMod,
     concurrencyMod,
     idempotencyMod,
+    // #1672: the capability suite's folder tree. Inert for every other suite — nothing else
+    // reads `cap_notes` or invokes a `cap/*` operation.
+    capMod,
 ];
 // -- live reads (#938) -------------------------------------------------------
 /**