refactor(kernel-utils): remove unused sheaf revocation API

revokePoint, revokeAll, and getExported are unused in application code —
the evm-wallet prototype rebuilds the sheaf wholesale when the grant set
changes rather than revoking individual sections. Remove the implementation,
the Grant type, the revoked flag in buildSection, and all associated tests.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: grypez

packages/kernel-utils/src/sheaf/sheafify.test.ts

@@ -516,105 +516,6 @@ describe('sheafify', () => {
     expect(await E(wallet).getBalance('alice')).toBe(42);
   });
 
-  // ---------------------------------------------------------------------------
-  // Revocation
-  // ---------------------------------------------------------------------------
-
-  it('revokePoint revokes sections covering the point', async () => {
-    const sections: PresheafSection<{ cost: number }>[] = [
-      {
-        exo: makeExo(
-          'Wallet:0',
-          M.interface('Wallet:0', {
-            getBalance: M.call(M.string()).returns(M.number()),
-          }),
-          { getBalance: (_acct: string) => 42 },
-        ) as unknown as Section,
-        metadata: constant({ cost: 1 }),
-      },
-    ];
-
-    const sheaf = sheafify({ name: 'Wallet', sections });
-    const wallet = sheaf.getGlobalSection({
-      async *lift(germs) {
-        yield germs[0]!;
-      },
-    });
-
-    expect(await E(wallet).getBalance('alice')).toBe(42);
-
-    sheaf.revokePoint('getBalance', 'alice');
-
-    // Entire section is revoked, not just the specific point
-    await expect(E(wallet).getBalance('alice')).rejects.toThrow(
-      'Section revoked',
-    );
-    await expect(E(wallet).getBalance('bob')).rejects.toThrow(
-      'Section revoked',
-    );
-  });
-
-  it('revokeAll revokes all sections', async () => {
-    const sections: PresheafSection<{ cost: number }>[] = [
-      {
-        exo: makeExo(
-          'Wallet:0',
-          M.interface('Wallet:0', {
-            getBalance: M.call(M.string()).returns(M.number()),
-          }),
-          { getBalance: (_acct: string) => 42 },
-        ) as unknown as Section,
-        metadata: constant({ cost: 1 }),
-      },
-    ];
-
-    const sheaf = sheafify({ name: 'Wallet', sections });
-    const wallet = sheaf.getGlobalSection({
-      async *lift(germs) {
-        yield germs[0]!;
-      },
-    });
-
-    expect(await E(wallet).getBalance('alice')).toBe(42);
-
-    sheaf.revokeAll();
-
-    await expect(E(wallet).getBalance('alice')).rejects.toThrow(
-      'Section revoked',
-    );
-  });
-
-  it('getExported returns union of active section guards', () => {
-    const sections: PresheafSection<{ cost: number }>[] = [
-      {
-        exo: makeExo(
-          'Wallet:0',
-          M.interface('Wallet:0', {
-            getBalance: M.call(M.string()).returns(M.number()),
-          }),
-          { getBalance: (_acct: string) => 42 },
-        ) as unknown as Section,
-        metadata: constant({ cost: 1 }),
-      },
-    ];
-
-    const sheaf = sheafify({ name: 'Wallet', sections });
-
-    // No sections granted yet
-    expect(sheaf.getExported()).toBeUndefined();
-
-    sheaf.getGlobalSection({
-      async *lift(germs) {
-        yield germs[0]!;
-      },
-    });
-
-    const exported = sheaf.getExported();
-    expect(exported).toBeDefined();
-    const { methodGuards } = getInterfaceGuardPayload(exported!);
-    expect(methodGuards).toHaveProperty('getBalance');
-  });
-
   it('getDiscoverableGlobalSection exposes __getDescription__', async () => {
     const schema = {
       getBalance: {
@@ -671,31 +572,4 @@ describe('sheafify', () => {
       (section as Record<string, unknown>)[GET_DESCRIPTION],
     ).toBeUndefined();
   });
-
-  it('getExported excludes revoked sections', () => {
-    const sections: PresheafSection<{ cost: number }>[] = [
-      {
-        exo: makeExo(
-          'Wallet:0',
-          M.interface('Wallet:0', {
-            getBalance: M.call(M.string()).returns(M.number()),
-          }),
-          { getBalance: (_acct: string) => 42 },
-        ) as unknown as Section,
-        metadata: constant({ cost: 1 }),
-      },
-    ];
-
-    const sheaf = sheafify({ name: 'Wallet', sections });
-    sheaf.getGlobalSection({
-      async *lift(germs) {
-        yield germs[0]!;
-      },
-    });
-
-    expect(sheaf.getExported()).toBeDefined();
-
-    sheaf.revokeAll();
-    expect(sheaf.getExported()).toBeUndefined();
-  });
 });

packages/kernel-utils/src/sheaf/sheafify.ts

@@ -2,7 +2,7 @@
  * Sheafify a presheaf into an authority manager.
  *
  * `sheafify({ name, sections })` returns a `Sheaf` — an immutable object
- * that tracks granted authority and produces revocable dispatch sections.
+ * that produces dispatch sections over a fixed presheaf.
  *
  * Each dispatch through a granted section:
  *   1. Computes the stalk (getStalk — presheaf sections matching the point)
@@ -28,7 +28,7 @@ import { collectSheafGuard } from './guard.ts';
 import type { MethodGuardPayload } from './guard.ts';
 import { evaluateMetadata, resolveMetaDataSpec } from './metadata.ts';
 import type { ResolvedMetaDataSpec } from './metadata.ts';
-import { getStalk, guardCoversPoint } from './stalk.ts';
+import { getStalk } from './stalk.ts';
 import type {
   EvaluatedSection,
   Lift,
@@ -178,13 +178,6 @@ const invokeExo = (exo: Section, method: string, args: unknown[]): unknown => {
   return fn.call(obj, ...args);
 };
 
-type Grant = {
-  exo: Section;
-  guard: InterfaceGuard;
-  revoke: () => void;
-  isRevoked: () => boolean;
-};
-
 type ResolvedSection<M extends Record<string, unknown>> = {
   exo: Section;
   spec: ResolvedMetaDataSpec<M> | undefined;
@@ -210,8 +203,6 @@ export const sheafify = <
           : resolveMetaDataSpec(section.metadata, compartment),
     })),
   );
-  const grants: Grant[] = [];
-
   const buildSection = ({
     guard,
     lift,
@@ -231,16 +222,10 @@ export const sheafify = <
             defaultGuards: 'passable',
           });
 
-    let revoked = false;
-
     const dispatch = async (
       method: string,
       args: unknown[],
     ): Promise<unknown> => {
-      if (revoked) {
-        throw new Error(`Section revoked: ${name}`);
-      }
-
       const stalk = getStalk(frozenSections, method, args);
       const evaluatedStalk: EvaluatedSection<MetaData>[] = stalk.map(
         (section) => ({
@@ -304,15 +289,6 @@ export const sheafify = <
           asyncGuard,
         )) as unknown as Section;
 
-    grants.push({
-      exo,
-      guard: resolvedGuard,
-      revoke: () => {
-        revoked = true;
-      },
-      isRevoked: () => revoked,
-    });
-
     return exo;
   };
 
@@ -351,39 +327,10 @@ export const sheafify = <
     schema: Record<string, MethodSchema>;
   }): object => buildSection({ guard: unionGuard(), lift, schema });
 
-  const revokePoint = (method: string, ...args: unknown[]): void => {
-    for (const grant of grants) {
-      if (!grant.isRevoked() && guardCoversPoint(grant.guard, method, args)) {
-        grant.revoke();
-      }
-    }
-  };
-
-  const getExported = (): InterfaceGuard | undefined => {
-    const activeExos = grants
-      .filter((grant) => !grant.isRevoked())
-      .map((grant) => grant.exo);
-    if (activeExos.length === 0) {
-      return undefined;
-    }
-    return collectSheafGuard(`${name}:exported`, activeExos);
-  };
-
-  const revokeAll = (): void => {
-    for (const grant of grants) {
-      if (!grant.isRevoked()) {
-        grant.revoke();
-      }
-    }
-  };
-
   return {
     getSection,
     getDiscoverableSection,
     getGlobalSection,
     getDiscoverableGlobalSection,
-    revokePoint,
-    getExported,
-    revokeAll,
   };
 };

packages/kernel-utils/src/sheaf/types.ts

@@ -121,10 +121,4 @@ export type Sheaf<MetaData extends Record<string, unknown>> = {
     lift: Lift<MetaData>;
     schema: Record<string, MethodSchema>;
   }) => object;
-  /** Revoke every granted section whose guard covers the point (method, ...args). */
-  revokePoint: (method: string, ...args: unknown[]) => void;
-  /** Union guard of all active (non-revoked) granted sections, or undefined. */
-  getExported: () => InterfaceGuard | undefined;
-  /** Revoke all granted sections. */
-  revokeAll: () => void;
 };