@substrat-run/contract-tests 0.114.0 → 0.117.0

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

@@ -37,7 +37,20 @@ export const scheduleModManifest = moduleManifest.parse({
     migrations: { journalDir: './migrations', compatibleFrom: '1.0.0' },
     attachmentTargets: [],
     entitlementKey: 'sched',
-    schedules: [{ operation: 'sched/tick', cadence: { everyMinutes: 60 }, permissions: ['sched:tick'] }],
+    schedules: [
+        { operation: 'sched/tick', cadence: { everyMinutes: 60 }, permissions: ['sched:tick'] },
+        // #1288's regression fixture, and it is not a silly name: `scheduleSpec.operation`
+        // is `z.string().min(1)`, so this IS a legal schedule, and its key is byte-for-byte
+        // the key the freshness expectation below writes under. Until `kind` joined the
+        // primary key of `_substrat_schedule_state` the two shared one row — each pass
+        // overwrote the other's verdict, and each read back the other's time. Declared here
+        // rather than in a module of its own so BOTH adapters' schedule suites carry it.
+        {
+            operation: 'freshness:sched.ticked',
+            cadence: { everyMinutes: 60 },
+            permissions: ['sched:tick'],
+        },
+    ],
     // #1232: a freshness expectation on the module's own emitted type — declared TWICE
     // with different windows, deliberately: the evaluator must collapse duplicates to
     // the tightest window (one row per (scope, eventType), or the drain dedupe eats one).
@@ -68,6 +81,51 @@ export const freshnessMod = {
     migrations: [],
     operations: {},
 };
+/**
+ * #1577: the module a resumable RUN acts through.
+ *
+ * The job's handler is NOT here — a job is host code (`registerJob`), so the suite
+ * hands the host a closure, which is precisely what an operation or consumer
+ * cannot be on the Cloudflare adapter. What has to be here is the operation the
+ * job's steps invoke, because the ScopeDO closes over a code-time module set and
+ * the step's write has to be a real write, through a real `ctx.check`, inside the
+ * scope — otherwise "no step before it repeated" is asserted against a counter in
+ * the test process and proves nothing about what survived a pass boundary.
+ *
+ * `jobs:write` is declared but NOT projected by any schedule: the module declares
+ * no schedules, so the suite grants it to `system:@test/jobs` explicitly with
+ * `grantToSystem`. That IS the shape a deployment uses — a job's authority is a
+ * grant a human can read in the permission diff and revoke per scope, same as a
+ * schedule's, and nothing about a job invents a second way in.
+ */
+export const jobsModManifest = moduleManifest.parse({
+    id: '@test/jobs',
+    version: '1.0.0',
+    kernelContract: '^0.0.1',
+    permissions: [{ key: 'jobs:write', description: 'record one walked item' }],
+    events: { emits: [], consumes: [] },
+    migrations: { journalDir: './migrations', compatibleFrom: '1.0.0' },
+    attachmentTargets: [],
+    entitlementKey: 'jobs',
+});
+export const jobsMod = {
+    manifest: jobsModManifest,
+    migrations: [
+        { version: '0001-init', sql: 'CREATE TABLE job_items (item TEXT NOT NULL)' },
+    ],
+    operations: {
+        // Deliberately NOT idempotent and NOT unique-keyed: a repeated step shows up as
+        // a DUPLICATE ROW rather than being silently absorbed, which is the only way the
+        // resume assertion can fail loudly when the memo stops working.
+        'jobs/record': (async (ctx, input) => {
+            assertAllowed(await ctx.check('jobs:write'));
+            ctx.sql.exec('INSERT INTO job_items (item) VALUES (?)', [input.item]);
+        }),
+        'jobs/items': ((ctx) => ctx.sql
+            .query('SELECT item FROM job_items ORDER BY rowid')
+            .map((r) => r.item)),
+    },
+};
 export const flowModManifest = moduleManifest.parse({
     id: '@test/flow',
     version: '1.0.0',
@@ -228,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
@@ -235,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
@@ -546,7 +611,90 @@ 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');
-const readDenialsOp = (ctx) => ctx.sql.query(`SELECT actor, permission, tenant_id, scope_id, operation, impersonation
+// #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) ----------------------------------------------------
 // A read, a bare-SQL write, and an intent. The bare-SQL write is the one that
@@ -795,6 +943,12 @@ export const scheduleMod = {
                 payload: {},
             });
         }),
+        // #1288: the colliding schedule's handler. Deliberately writes nothing and emits
+        // nothing — its `_substrat_schedule_state` row IS the evidence it ran, which is
+        // the fact under test. It holds `sched:tick` because its schedule declares it.
+        'freshness:sched.ticked': (async (ctx) => {
+            assertAllowed(await ctx.check('sched:tick'));
+        }),
         // Checks a permission the schedule never granted the system principal — invoked
         // directly through the system door, it must be DENIED, proving ctx.check is the gate.
         'sched/needs-admin': (async (ctx) => {
@@ -802,7 +956,11 @@ export const scheduleMod = {
         }),
         'sched/count': ((ctx) => ctx.sql.query('SELECT COUNT(*) AS n FROM sched_ticks')[0].n),
         'sched/read-outbox': ((ctx) => ctx.sql.query('SELECT type, actor, operation FROM _substrat_outbox ORDER BY id')),
-        'sched/schedule-state': ((ctx) => ctx.sql.query('SELECT schedule_op, last_status FROM _substrat_schedule_state ORDER BY schedule_op')),
+        // #1288: `kind` is selected, and the order leads with it — two rows may now share
+        // a `schedule_op`, so ordering by that alone leaves the pair's order to the query
+        // planner and an assertion on the array would be flaky rather than wrong.
+        'sched/schedule-state': ((ctx) => ctx.sql.query(`SELECT kind, schedule_op, last_status FROM _substrat_schedule_state
+          ORDER BY kind, schedule_op`)),
     },
 };
 export const flowMod = {
@@ -824,7 +982,7 @@ export const flowMod = {
             });
         }),
         'flow/log': ((ctx) => ctx.sql.query('SELECT event_id, type FROM flow_log ORDER BY event_id')),
-        'flow/deliveries': ((ctx) => ctx.sql.query(`SELECT event_id, consumer_module, error FROM _substrat_deliveries
+        'flow/deliveries': ((ctx) => ctx.sql.query(`SELECT event_id, consumer_module, error, invocation_id FROM _substrat_deliveries
          WHERE consumer_module = '@test/flow' ORDER BY event_id`)),
         'flow/step2-actors': ((ctx) => ctx.sql.query(`SELECT actor, operation FROM _substrat_outbox WHERE type = 'flow.step2'`)),
         // #1237: the causal edge, straight off the spine. Both types, so a test can see
@@ -935,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,
@@ -973,6 +1135,9 @@ export const permMod = {
             return { revoked: true };
         }),
     },
+    consumers: {
+        'perm.check-requested': checkRequestedConsumer,
+    },
 };
 export const connectorModManifest = moduleManifest.parse({
     id: '@test/connector',
@@ -1515,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,
@@ -1526,13 +1863,120 @@ export const contractTestModules = [
     impersonationEchoMod,
     connectorMod,
     scheduleMod,
+    // #1577: the operation a resumable run's steps write through. Inert for every
+    // other suite — nothing else reads `job_items`.
+    jobsMod,
     atomicMod,
     searchMod,
     listMod,
     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) -------------------------------------------------------
+/**
+ * A module for the live-read fan-out, with two entity types that differ in exactly
+ * one respect: `note` is declared watchable and `ledger` is not.
+ *
+ * Deliberately NOT in `contractTestModules`. Every scope in the kit shares one module
+ * set, and a module declaring `liveTargets` there would give every other suite's scope
+ * a fan-out to run on every invoke — changing what those suites exercise in order to
+ * test this one. Adapters that can host live reads mount it on a scope host of its own.
+ *
+ * The undeclared `ledger` is the fixture for the fail-closed half of the rule, and it
+ * is the half worth having a fixture for: "an entity type nobody declared reaches
+ * nobody" is a sentence that is trivially true of an implementation that also announces
+ * nothing at all, so the suite proves it against a `note` that DOES arrive.
+ */
+export const liveModManifest = moduleManifest.parse({
+    id: '@test/live',
+    version: '1.0.0',
+    kernelContract: '^0.0.1',
+    permissions: [
+        { key: 'live:read', description: 'read a note — and therefore watch it change' },
+        { key: 'live:write', description: 'touch a note' },
+    ],
+    events: {
+        emits: [
+            { type: 'live.note-touched', schemaVersion: 1 },
+            { type: 'live.ledger-touched', schemaVersion: 1 },
+            // Declared for the reason permMod declares them: an attachment target implies
+            // these, and the module's emitted-event set should say so rather than have the
+            // kernel emit a type the manifest never mentions.
+            { type: 'attachment.added', schemaVersion: 1 },
+            { type: 'attachment.removed', schemaVersion: 1 },
+        ],
+        consumes: [],
+    },
+    migrations: { journalDir: './migrations', compatibleFrom: '1.0.0' },
+    // `note` is attachable as well as watchable, and that overlap is the fixture for a
+    // second committing path: `attachmentAdd`/`attachmentRemove` emit about the entity
+    // too, so a watcher of `note` must hear those exactly as it hears an operation's
+    // own event. Without this the attachment path would have had no live-read test at
+    // all, which is how it came to be the one door the fan-out was not wired into.
+    attachmentTargets: [
+        { entityType: 'note', readPermission: 'live:read', writePermission: 'live:write' },
+    ],
+    // The declaration under test. `note` is watchable, gated by the key that reads it;
+    // `ledger` is absent, and its absence is the assertion.
+    liveTargets: [{ entityType: 'note', readPermission: 'live:read' }],
+    entitlementKey: 'live',
+});
+/** Touch a note — one write, one event about ONE entity, which is what a subscriber hears. */
+const liveTouchOp = async (ctx, input) => {
+    assertAllowed(await ctx.check(permissionKey.parse('live:write')));
+    ctx.emit({
+        type: 'live.note-touched',
+        schemaVersion: 1,
+        entity: { entityType: 'note', entityId: input.noteId },
+        piiClass: 'none',
+        payload: {},
+    });
+    return { noteId: input.noteId };
+};
+/** The same write against the entity type nobody declared watchable. */
+const liveTouchLedgerOp = async (ctx, input) => {
+    assertAllowed(await ctx.check(permissionKey.parse('live:write')));
+    ctx.emit({
+        type: 'live.ledger-touched',
+        schemaVersion: 1,
+        entity: { entityType: 'ledger', entityId: input.ledgerId },
+        piiClass: 'none',
+        payload: {},
+    });
+    return { ledgerId: input.ledgerId };
+};
+/**
+ * Withdraw a read grant on one note, the way an app un-shares a record.
+ *
+ * Deliberately UNGUARDED by an operation-level check, exactly as `perm/share` is and
+ * for the same reason: the guardrail under test lives inside the verb — `ctx.revoke`
+ * re-checks the caller's own decision on that entity — so wrapping it in a second
+ * check here would only prove the wrapper.
+ *
+ * It exists so the suite can take authority away MID-SOCKET. There is no `HostAdmin`
+ * verb that withdraws an entity-narrowed grant, and that is the right shape: narrowing
+ * and un-narrowing are things an app does on a person's behalf, not things a platform
+ * actor reaches in.
+ */
+const liveUnshareOp = async (ctx, input) => {
+    await ctx.revoke(principalId.parse(input.principal), permissionKey.parse('live:read'), {
+        entityType: 'note',
+        entityId: input.noteId,
+    });
+};
+export const liveMod = {
+    manifest: liveModManifest,
+    migrations: [],
+    operations: {
+        'live/touch': liveTouchOp,
+        'live/touch-ledger': liveTouchLedgerOp,
+        'live/unshare': liveUnshareOp,
+    },
+};
 export const brokenModManifest = moduleManifest.parse({
     id: '@test/broken',
     version: '1.0.0',