@workglow/test-contract 0.6.1

package/dist/entitlement-profile.js

@@ -0,0 +1,436 @@
+// src/entitlement-profile/fixtures.ts
+import {
+  Entitlements
+} from "@workglow/task-graph";
+var NETWORK_HTTP_REQUIRED = {
+  id: Entitlements.NETWORK_HTTP,
+  reason: "Conformance fixture: HTTP request"
+};
+var FILESYSTEM_REQUIRED = {
+  id: Entitlements.FILESYSTEM,
+  reason: "Conformance fixture: filesystem access"
+};
+var OPTIONAL_CREDENTIAL = {
+  id: Entitlements.CREDENTIAL,
+  reason: "Conformance fixture: optional credential",
+  optional: true
+};
+var SCOPED_FILESYSTEM_TMP_OK = {
+  id: Entitlements.FILESYSTEM_READ,
+  reason: "Conformance fixture: scoped read of /tmp",
+  resources: ["/tmp/data.json"]
+};
+var SCOPED_FILESYSTEM_ETC_BAD = {
+  id: Entitlements.FILESYSTEM_READ,
+  reason: "Conformance fixture: scoped read of /etc",
+  resources: ["/etc/passwd"]
+};
+var UNCOVERED_FOO = {
+  id: "foo:bar",
+  reason: "Conformance fixture: uncovered entitlement"
+};
+function createControllableSignalSource() {
+  const listeners = new Set;
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      let unsubbed = false;
+      return () => {
+        if (unsubbed)
+          return;
+        unsubbed = true;
+        listeners.delete(listener);
+      };
+    },
+    emit(signal) {
+      for (const l of listeners)
+        l(signal);
+    }
+  };
+}
+// src/entitlement-profile/runEntitlementProfileConformance.ts
+import { afterAll, beforeAll, describe as describe12 } from "vitest";
+
+// src/entitlement-profile/assertions/denialShape.ts
+import { describe, expect, it } from "vitest";
+function denialShapeBlock(_opts, getHandle) {
+  describe("Denial shape", () => {
+    it("denial.entitlement is reference-equal to the requested entitlement", async () => {
+      const profile = getHandle().profile;
+      const result = await profile.requestEntitlement(UNCOVERED_FOO);
+      expect(result.outcome).toBe("denied");
+      if (result.outcome === "denied") {
+        expect(result.denial.entitlement).toBe(UNCOVERED_FOO);
+      }
+    });
+    it("denial.reason matches the EntitlementDenialReason union", async () => {
+      const profile = getHandle().profile;
+      const result = await profile.requestEntitlement(UNCOVERED_FOO);
+      if (result.outcome === "denied") {
+        expect(["policy-deny", "default-deny", "user-deny"]).toContain(result.denial.reason);
+      }
+    });
+    it("policy-deny and user-deny carry matchedRule; default-deny does not", async () => {
+      const profile = getHandle().profile;
+      const result = await profile.requestEntitlement(UNCOVERED_FOO);
+      if (result.outcome === "denied") {
+        const d = result.denial;
+        if (d.reason === "default-deny") {
+          expect("matchedRule" in d).toBe(false);
+        } else {
+          expect(d.matchedRule).toBeDefined();
+        }
+      }
+    });
+  });
+}
+
+// src/entitlement-profile/assertions/dispose.ts
+import { describe as describe2, expect as expect2, it as it2 } from "vitest";
+function disposeBlock(opts, _getHandle) {
+  describe2("Dispose", () => {
+    it2("dispose is idempotent (two calls succeed)", async () => {
+      const local = await opts.factory();
+      try {
+        await local.profile.dispose();
+        await expect2(local.profile.dispose()).resolves.toBeUndefined();
+      } finally {
+        await local.dispose();
+      }
+    });
+    it2.skipIf(!opts.capabilities.mutableSignalSource)("after dispose, signal source no longer drives events", async () => {
+      const local = await opts.factory();
+      try {
+        if (!local.simulateSignal)
+          return;
+        const events = [];
+        local.profile.subscribe((e) => events.push(e));
+        await local.profile.requestEntitlement(NETWORK_HTTP_REQUIRED);
+        await local.profile.dispose();
+        local.simulateSignal({ kind: "revoke", entitlement: NETWORK_HTTP_REQUIRED });
+        await new Promise((r) => setTimeout(r, 0));
+        expect2(events).toEqual([]);
+      } finally {
+        await local.dispose();
+      }
+    });
+  });
+}
+
+// src/entitlement-profile/assertions/hierarchyHonoring.ts
+import { describe as describe3, expect as expect3, it as it3 } from "vitest";
+function hierarchyHonoringBlock(opts, getHandle) {
+  describe3.skipIf(!opts.capabilities.hierarchyHonoring)("Hierarchy honoring", () => {
+    it3("granting a parent ID covers child IDs in the namespace", async () => {
+      const profile = getHandle().profile;
+      const parentGrant = profile.surface().find((g) => !g.id.includes(":") && !g.resources);
+      if (!parentGrant) {
+        return;
+      }
+      const childId = `${parentGrant.id}:probe`;
+      const result = await profile.requestEntitlement({ id: childId });
+      expect3(result.outcome).toBe("granted");
+    });
+  });
+}
+
+// src/entitlement-profile/assertions/optionalNeverDenied.ts
+import { describe as describe4, expect as expect4, it as it4 } from "vitest";
+function optionalNeverDeniedBlock(_opts, getHandle) {
+  describe4("Optional entitlements never denied", () => {
+    it4("requestEntitlement returns granted for an optional entitlement", async () => {
+      const profile = getHandle().profile;
+      const result = await profile.requestEntitlement(OPTIONAL_CREDENTIAL);
+      expect4(result.outcome).toBe("granted");
+    });
+    it4("checkAll returns no denials for an optional entitlement even when uncovered", async () => {
+      const profile = getHandle().profile;
+      const denials = await profile.checkAll({
+        entitlements: [{ id: "uncovered:optional", optional: true }]
+      });
+      expect4(denials).toEqual([]);
+    });
+  });
+}
+
+// src/entitlement-profile/assertions/requestEntitlementShape.ts
+import { describe as describe5, expect as expect5, it as it5 } from "vitest";
+function requestEntitlementShapeBlock(_opts, getHandle) {
+  describe5("requestEntitlement shape parity with checkAll", () => {
+    it5("granted: requestEntitlement and checkAll agree", async () => {
+      const profile = getHandle().profile;
+      const isCovered = profile.surface().some((g) => g.id === NETWORK_HTTP_REQUIRED.id && !g.resources);
+      if (!isCovered)
+        return;
+      const single = await profile.requestEntitlement(NETWORK_HTTP_REQUIRED);
+      const all = await profile.checkAll({ entitlements: [NETWORK_HTTP_REQUIRED] });
+      expect5(single.outcome).toBe("granted");
+      expect5(all).toEqual([]);
+    });
+    it5("denied: requestEntitlement and checkAll agree on reason", async () => {
+      const profile = getHandle().profile;
+      const single = await profile.requestEntitlement(UNCOVERED_FOO);
+      const all = await profile.checkAll({ entitlements: [UNCOVERED_FOO] });
+      expect5(single.outcome).toBe("denied");
+      expect5(all).toHaveLength(1);
+      if (single.outcome === "denied") {
+        expect5(all[0].reason).toBe(single.denial.reason);
+        if (single.denial.reason !== "default-deny") {
+          expect5(all[0].matchedRule).toEqual(single.denial.matchedRule);
+        }
+      }
+    });
+  });
+}
+
+// src/entitlement-profile/assertions/resourceScoping.ts
+import { describe as describe6, expect as expect6, it as it6 } from "vitest";
+function resourceScopingBlock(opts, getHandle) {
+  describe6.skipIf(!opts.capabilities.resourceScoping)("Resource scoping", () => {
+    it6("scoped read succeeds when the profile broadly grants filesystem", async () => {
+      const profile = getHandle().profile;
+      const hasBroadFilesystem = profile.surface().some((g) => g.id === "filesystem" && !g.resources);
+      if (!hasBroadFilesystem) {
+        return;
+      }
+      const result = await profile.requestEntitlement(SCOPED_FILESYSTEM_TMP_OK);
+      expect6(result.outcome).toBe("granted");
+    });
+    it6("scoped read fails when the profile does not grant filesystem at all", async () => {
+      const profile = getHandle().profile;
+      const hasFilesystem = profile.surface().some((g) => g.id === "filesystem" || g.id === "filesystem:read");
+      if (hasFilesystem) {
+        return;
+      }
+      const result = await profile.requestEntitlement(SCOPED_FILESYSTEM_ETC_BAD);
+      expect6(result.outcome).toBe("denied");
+    });
+  });
+}
+
+// src/entitlement-profile/assertions/subscribeGrant.ts
+import { describe as describe7, expect as expect7, it as it7 } from "vitest";
+function subscribeGrantBlock(opts, getHandle) {
+  describe7.skipIf(!opts.capabilities.mutableSignalSource)("Subscribe grant", () => {
+    it7("emits granted when previously-denied entitlement becomes granted", async () => {
+      const handle = getHandle();
+      if (!handle.simulateSignal) {
+        throw new Error("simulateSignal must be present when mutableSignalSource is true");
+      }
+      const events = [];
+      const unsub = handle.profile.subscribe((e) => events.push(e));
+      try {
+        const before = await handle.profile.requestEntitlement(UNCOVERED_FOO);
+        if (before.outcome !== "denied")
+          return;
+        handle.simulateSignal({ kind: "grant", entitlement: UNCOVERED_FOO });
+        await new Promise((r) => setTimeout(r, 0));
+        const granted = events.find((e) => e.kind === "granted");
+        expect7(granted).toBeDefined();
+        expect7(granted?.entitlement.id).toBe(UNCOVERED_FOO.id);
+      } finally {
+        unsub();
+      }
+    });
+    it7("does not emit when grant signal arrives for already-granted entitlement", async () => {
+      const handle = getHandle();
+      if (!handle.simulateSignal)
+        return;
+      const events = [];
+      const unsub = handle.profile.subscribe((e) => events.push(e));
+      try {
+        const before = await handle.profile.requestEntitlement(NETWORK_HTTP_REQUIRED);
+        if (before.outcome !== "granted")
+          return;
+        handle.simulateSignal({ kind: "grant", entitlement: NETWORK_HTTP_REQUIRED });
+        await new Promise((r) => setTimeout(r, 0));
+        expect7(events).toEqual([]);
+      } finally {
+        unsub();
+      }
+    });
+  });
+}
+
+// src/entitlement-profile/assertions/subscribeReload.ts
+import { describe as describe8, expect as expect8, it as it8 } from "vitest";
+function subscribeReloadBlock(opts, getHandle) {
+  describe8.skipIf(!opts.capabilities.mutableSignalSource)("Subscribe reload", () => {
+    it8("reload fires events only for previously-queried entitlements that flipped", async () => {
+      const handle = getHandle();
+      if (!handle.simulateSignal)
+        return;
+      const events = [];
+      await handle.profile.requestEntitlement(NETWORK_HTTP_REQUIRED);
+      await handle.profile.requestEntitlement(UNCOVERED_FOO);
+      const unsub = handle.profile.subscribe((e) => events.push(e));
+      try {
+        handle.simulateSignal({ kind: "reload" });
+        await new Promise((r) => setTimeout(r, 0));
+        expect8(events.map((e) => e.entitlement.id)).toEqual([NETWORK_HTTP_REQUIRED.id]);
+      } finally {
+        unsub();
+      }
+    });
+  });
+}
+
+// src/entitlement-profile/assertions/subscribeRevocation.ts
+import { describe as describe9, expect as expect9, it as it9 } from "vitest";
+function subscribeRevocationBlock(opts, getHandle) {
+  describe9.skipIf(!opts.capabilities.mutableSignalSource)("Subscribe revocation", () => {
+    it9("emits revoked when previously-granted entitlement becomes denied", async () => {
+      const handle = getHandle();
+      if (!handle.simulateSignal) {
+        throw new Error("simulateSignal must be present when mutableSignalSource is true");
+      }
+      const events = [];
+      const unsub = handle.profile.subscribe((e) => events.push(e));
+      try {
+        const before = await handle.profile.requestEntitlement(NETWORK_HTTP_REQUIRED);
+        if (before.outcome !== "granted") {
+          return;
+        }
+        handle.simulateSignal({ kind: "revoke", entitlement: NETWORK_HTTP_REQUIRED });
+        await new Promise((r) => setTimeout(r, 0));
+        const revoked = events.find((e) => e.kind === "revoked");
+        expect9(revoked).toBeDefined();
+        expect9(revoked?.entitlement.id).toBe(NETWORK_HTTP_REQUIRED.id);
+      } finally {
+        unsub();
+      }
+    });
+    it9("does not emit when no flip occurs (revoke for never-granted entitlement)", async () => {
+      const handle = getHandle();
+      if (!handle.simulateSignal)
+        return;
+      const events = [];
+      const unsub = handle.profile.subscribe((e) => events.push(e));
+      try {
+        await handle.profile.requestEntitlement(UNCOVERED_FOO);
+        handle.simulateSignal({ kind: "revoke", entitlement: UNCOVERED_FOO });
+        await new Promise((r) => setTimeout(r, 0));
+        expect9(events).toEqual([]);
+      } finally {
+        unsub();
+      }
+    });
+  });
+}
+
+// src/entitlement-profile/assertions/surfaceCoverage.ts
+import { describe as describe10, expect as expect10, it as it10 } from "vitest";
+function surfaceCoverageBlock(opts, getHandle) {
+  describe10("Surface coverage", () => {
+    it10("surface() includes every entitlement listed in expected.surfaceIncludes", async () => {
+      const profile = getHandle().profile;
+      const surface = profile.surface().map((g) => g.id);
+      for (const id of opts.expected.surfaceIncludes) {
+        expect10(surface).toContain(id);
+      }
+    });
+    it10("surface() excludes every entitlement listed in expected.surfaceExcludes", async () => {
+      const profile = getHandle().profile;
+      const surface = profile.surface().map((g) => g.id);
+      for (const id of opts.expected.surfaceExcludes) {
+        expect10(surface).not.toContain(id);
+      }
+    });
+    it10("requestEntitlement returns granted for an entitlement covered by surface", async () => {
+      const profile = getHandle().profile;
+      const firstGrant = profile.surface()[0];
+      if (!firstGrant) {
+        return;
+      }
+      const result = await profile.requestEntitlement({ id: firstGrant.id });
+      expect10(result.outcome).toBe("granted");
+    });
+    it10("requestEntitlement returns denied with default-deny reason for an uncovered entitlement", async () => {
+      const profile = getHandle().profile;
+      const result = await profile.requestEntitlement(UNCOVERED_FOO);
+      expect10(result.outcome).toBe("denied");
+      if (result.outcome === "denied") {
+        expect10(result.denial.reason).toBe("default-deny");
+        expect10(result.denial.entitlement).toBe(UNCOVERED_FOO);
+      }
+    });
+  });
+}
+
+// src/entitlement-profile/assertions/unsubscribeIdempotent.ts
+import { describe as describe11, expect as expect11, it as it11 } from "vitest";
+function unsubscribeIdempotentBlock(opts, getHandle) {
+  describe11.skipIf(!opts.capabilities.mutableSignalSource)("Unsubscribe idempotent", () => {
+    it11("calling unsubscribe twice does not throw", () => {
+      const profile = getHandle().profile;
+      const unsub = profile.subscribe(() => {});
+      unsub();
+      expect11(() => unsub()).not.toThrow();
+    });
+    it11("after unsubscribe, no further events are delivered", async () => {
+      const handle = getHandle();
+      if (!handle.simulateSignal)
+        return;
+      const events = [];
+      const unsub = handle.profile.subscribe((e) => events.push(e));
+      await handle.profile.requestEntitlement(NETWORK_HTTP_REQUIRED);
+      unsub();
+      handle.simulateSignal({ kind: "revoke", entitlement: NETWORK_HTTP_REQUIRED });
+      await new Promise((r) => setTimeout(r, 0));
+      expect11(events).toEqual([]);
+    });
+  });
+}
+
+// src/entitlement-profile/runEntitlementProfileConformance.ts
+function runEntitlementProfileConformance(opts) {
+  describe12.skipIf(opts.skip)(`EntitlementProfile conformance: ${opts.name}`, () => {
+    let handle;
+    const getHandle = () => {
+      if (!handle)
+        throw new Error("conformance handle not initialized");
+      return handle;
+    };
+    beforeAll(async () => {
+      handle = await opts.factory();
+    }, opts.timeout);
+    afterAll(async () => {
+      if (handle)
+        await handle.dispose();
+    });
+    surfaceCoverageBlock(opts, getHandle);
+    hierarchyHonoringBlock(opts, getHandle);
+    resourceScopingBlock(opts, getHandle);
+    optionalNeverDeniedBlock(opts, getHandle);
+    denialShapeBlock(opts, getHandle);
+    requestEntitlementShapeBlock(opts, getHandle);
+    subscribeRevocationBlock(opts, getHandle);
+    subscribeGrantBlock(opts, getHandle);
+    subscribeReloadBlock(opts, getHandle);
+    unsubscribeIdempotentBlock(opts, getHandle);
+    disposeBlock(opts, getHandle);
+  });
+}
+export {
+  FILESYSTEM_REQUIRED,
+  NETWORK_HTTP_REQUIRED,
+  OPTIONAL_CREDENTIAL,
+  SCOPED_FILESYSTEM_ETC_BAD,
+  SCOPED_FILESYSTEM_TMP_OK,
+  UNCOVERED_FOO,
+  createControllableSignalSource,
+  denialShapeBlock,
+  disposeBlock,
+  hierarchyHonoringBlock,
+  optionalNeverDeniedBlock,
+  requestEntitlementShapeBlock,
+  resourceScopingBlock,
+  runEntitlementProfileConformance,
+  subscribeGrantBlock,
+  subscribeReloadBlock,
+  subscribeRevocationBlock,
+  surfaceCoverageBlock,
+  unsubscribeIdempotentBlock
+};
+
+//# debugId=A4B432BFC9E613D164756E2164756E21

package/dist/entitlement-profile.js.map

@@ -0,0 +1,22 @@
+{
+  "version": 3,
+  "sources": ["../src/entitlement-profile/fixtures.ts", "../src/entitlement-profile/runEntitlementProfileConformance.ts", "../src/entitlement-profile/assertions/denialShape.ts", "../src/entitlement-profile/assertions/dispose.ts", "../src/entitlement-profile/assertions/hierarchyHonoring.ts", "../src/entitlement-profile/assertions/optionalNeverDenied.ts", "../src/entitlement-profile/assertions/requestEntitlementShape.ts", "../src/entitlement-profile/assertions/resourceScoping.ts", "../src/entitlement-profile/assertions/subscribeGrant.ts", "../src/entitlement-profile/assertions/subscribeReload.ts", "../src/entitlement-profile/assertions/subscribeRevocation.ts", "../src/entitlement-profile/assertions/surfaceCoverage.ts", "../src/entitlement-profile/assertions/unsubscribeIdempotent.ts"],
+  "sourcesContent": [
+    "/**\n * @license\n * Copyright 2026 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport {\n  Entitlements,\n  type EntitlementSignal,\n  type IEntitlementSignalSource,\n  type TaskEntitlement,\n} from \"@workglow/task-graph\";\n\nexport const NETWORK_HTTP_REQUIRED: TaskEntitlement = {\n  id: Entitlements.NETWORK_HTTP,\n  reason: \"Conformance fixture: HTTP request\",\n};\n\nexport const FILESYSTEM_REQUIRED: TaskEntitlement = {\n  id: Entitlements.FILESYSTEM,\n  reason: \"Conformance fixture: filesystem access\",\n};\n\nexport const OPTIONAL_CREDENTIAL: TaskEntitlement = {\n  id: Entitlements.CREDENTIAL,\n  reason: \"Conformance fixture: optional credential\",\n  optional: true,\n};\n\nexport const SCOPED_FILESYSTEM_TMP_OK: TaskEntitlement = {\n  id: Entitlements.FILESYSTEM_READ,\n  reason: \"Conformance fixture: scoped read of /tmp\",\n  resources: [\"/tmp/data.json\"],\n};\n\nexport const SCOPED_FILESYSTEM_ETC_BAD: TaskEntitlement = {\n  id: Entitlements.FILESYSTEM_READ,\n  reason: \"Conformance fixture: scoped read of /etc\",\n  resources: [\"/etc/passwd\"],\n};\n\n/** Guaranteed not to appear in any built-in profile surface. */\nexport const UNCOVERED_FOO: TaskEntitlement = {\n  id: \"foo:bar\",\n  reason: \"Conformance fixture: uncovered entitlement\",\n};\n\n/**\n * In-memory signal source for the Custom_Profile shim. The returned source\n * exposes `emit` so the shim's `simulateSignal` can drive listeners.\n */\nexport interface ControllableSignalSource extends IEntitlementSignalSource {\n  emit(signal: EntitlementSignal): void;\n}\n\nexport function createControllableSignalSource(): ControllableSignalSource {\n  const listeners = new Set<(s: EntitlementSignal) => void>();\n  return {\n    subscribe(listener) {\n      listeners.add(listener);\n      let unsubbed = false;\n      return () => {\n        if (unsubbed) return;\n        unsubbed = true;\n        listeners.delete(listener);\n      };\n    },\n    emit(signal) {\n      for (const l of listeners) l(signal);\n    },\n  };\n}\n",
+    "/**\n * @license\n * Copyright 2026 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { afterAll, beforeAll, describe } from \"vitest\";\n\nimport { denialShapeBlock } from \"./assertions/denialShape\";\nimport { disposeBlock } from \"./assertions/dispose\";\nimport { hierarchyHonoringBlock } from \"./assertions/hierarchyHonoring\";\nimport { optionalNeverDeniedBlock } from \"./assertions/optionalNeverDenied\";\nimport { requestEntitlementShapeBlock } from \"./assertions/requestEntitlementShape\";\nimport { resourceScopingBlock } from \"./assertions/resourceScoping\";\nimport { subscribeGrantBlock } from \"./assertions/subscribeGrant\";\nimport { subscribeReloadBlock } from \"./assertions/subscribeReload\";\nimport { subscribeRevocationBlock } from \"./assertions/subscribeRevocation\";\nimport { surfaceCoverageBlock } from \"./assertions/surfaceCoverage\";\nimport { unsubscribeIdempotentBlock } from \"./assertions/unsubscribeIdempotent\";\nimport type {\n  EntitlementProfileConformanceHandle,\n  EntitlementProfileConformanceOpts,\n} from \"./types\";\n\nexport function runEntitlementProfileConformance(opts: EntitlementProfileConformanceOpts): void {\n  describe.skipIf(opts.skip)(`EntitlementProfile conformance: ${opts.name}`, () => {\n    let handle: EntitlementProfileConformanceHandle | undefined;\n    const getHandle = (): EntitlementProfileConformanceHandle => {\n      if (!handle) throw new Error(\"conformance handle not initialized\");\n      return handle;\n    };\n\n    beforeAll(async () => {\n      handle = await opts.factory();\n    }, opts.timeout);\n\n    afterAll(async () => {\n      if (handle) await handle.dispose();\n    });\n\n    // Assertion blocks are imported and invoked here as they are added.\n    surfaceCoverageBlock(opts, getHandle);\n    hierarchyHonoringBlock(opts, getHandle);\n    resourceScopingBlock(opts, getHandle);\n    optionalNeverDeniedBlock(opts, getHandle);\n    denialShapeBlock(opts, getHandle);\n    requestEntitlementShapeBlock(opts, getHandle);\n    subscribeRevocationBlock(opts, getHandle);\n    subscribeGrantBlock(opts, getHandle);\n    subscribeReloadBlock(opts, getHandle);\n    unsubscribeIdempotentBlock(opts, getHandle);\n    disposeBlock(opts, getHandle);\n  });\n}\n",
+    "/**\n * @license\n * Copyright 2026 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { describe, expect, it } from \"vitest\";\n\nimport { UNCOVERED_FOO } from \"../fixtures\";\nimport type {\n  EntitlementProfileConformanceHandle,\n  EntitlementProfileConformanceOpts,\n} from \"../types\";\n\n/**\n * The denial returned by requestEntitlement for an uncovered entitlement\n * must satisfy the EntitlementDenial discriminated union: a `reason` of\n * \"policy-deny\" / \"user-deny\" requires `matchedRule`; \"default-deny\"\n * forbids it.\n */\nexport function denialShapeBlock(\n  _opts: EntitlementProfileConformanceOpts,\n  getHandle: () => EntitlementProfileConformanceHandle\n): void {\n  describe(\"Denial shape\", () => {\n    it(\"denial.entitlement is reference-equal to the requested entitlement\", async () => {\n      const profile = getHandle().profile;\n      const result = await profile.requestEntitlement(UNCOVERED_FOO);\n      expect(result.outcome).toBe(\"denied\");\n      if (result.outcome === \"denied\") {\n        expect(result.denial.entitlement).toBe(UNCOVERED_FOO);\n      }\n    });\n\n    it(\"denial.reason matches the EntitlementDenialReason union\", async () => {\n      const profile = getHandle().profile;\n      const result = await profile.requestEntitlement(UNCOVERED_FOO);\n      if (result.outcome === \"denied\") {\n        expect([\"policy-deny\", \"default-deny\", \"user-deny\"]).toContain(result.denial.reason);\n      }\n    });\n\n    it(\"policy-deny and user-deny carry matchedRule; default-deny does not\", async () => {\n      const profile = getHandle().profile;\n      const result = await profile.requestEntitlement(UNCOVERED_FOO);\n      if (result.outcome === \"denied\") {\n        const d = result.denial;\n        if (d.reason === \"default-deny\") {\n          // Discriminated union: default-deny variant has no matchedRule property.\n          expect(\"matchedRule\" in d).toBe(false);\n        } else {\n          // policy-deny / user-deny carry matchedRule.\n          expect(d.matchedRule).toBeDefined();\n        }\n      }\n    });\n  });\n}\n",
+    "/**\n * @license\n * Copyright 2026 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { describe, expect, it } from \"vitest\";\n\nimport type { EntitlementChangeEvent } from \"@workglow/task-graph\";\nimport { NETWORK_HTTP_REQUIRED } from \"../fixtures\";\nimport type {\n  EntitlementProfileConformanceHandle,\n  EntitlementProfileConformanceOpts,\n} from \"../types\";\n\n/**\n * dispose() is idempotent. After dispose, a simulateSignal does not deliver\n * events to listeners that subscribed before dispose.\n *\n * NOTE: This block uses an isolated profile via the factory, not the shared\n * conformance handle, because disposing the shared handle would break later\n * blocks. The factory is invoked again here; afterAll on the shared handle\n * still runs against its own profile.\n */\nexport function disposeBlock(\n  opts: EntitlementProfileConformanceOpts,\n  _getHandle: () => EntitlementProfileConformanceHandle\n): void {\n  describe(\"Dispose\", () => {\n    it(\"dispose is idempotent (two calls succeed)\", async () => {\n      const local = await opts.factory();\n      try {\n        await local.profile.dispose();\n        await expect(local.profile.dispose()).resolves.toBeUndefined();\n      } finally {\n        // local.dispose() is itself idempotent and will exercise dispose() again.\n        await local.dispose();\n      }\n    });\n\n    it.skipIf(!opts.capabilities.mutableSignalSource)(\n      \"after dispose, signal source no longer drives events\",\n      async () => {\n        const local = await opts.factory();\n        try {\n          if (!local.simulateSignal) return;\n          const events: EntitlementChangeEvent[] = [];\n          local.profile.subscribe((e) => events.push(e));\n          await local.profile.requestEntitlement(NETWORK_HTTP_REQUIRED);\n          await local.profile.dispose();\n          local.simulateSignal({ kind: \"revoke\", entitlement: NETWORK_HTTP_REQUIRED });\n          await new Promise((r) => setTimeout(r, 0));\n          expect(events).toEqual([]);\n        } finally {\n          await local.dispose();\n        }\n      }\n    );\n  });\n}\n",
+    "/**\n * @license\n * Copyright 2026 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { describe, expect, it } from \"vitest\";\n\nimport type {\n  EntitlementProfileConformanceHandle,\n  EntitlementProfileConformanceOpts,\n} from \"../types\";\n\n/**\n * If the profile surface includes a parent entitlement (e.g. \"network\"),\n * requesting a child entitlement (e.g. \"network:http\") must be granted.\n */\nexport function hierarchyHonoringBlock(\n  opts: EntitlementProfileConformanceOpts,\n  getHandle: () => EntitlementProfileConformanceHandle\n): void {\n  describe.skipIf(!opts.capabilities.hierarchyHonoring)(\"Hierarchy honoring\", () => {\n    it(\"granting a parent ID covers child IDs in the namespace\", async () => {\n      const profile = getHandle().profile;\n      // Find a grant whose ID has no colon (a parent), then probe a child.\n      const parentGrant = profile.surface().find((g) => !g.id.includes(\":\") && !g.resources);\n      if (!parentGrant) {\n        // No broad parent grant in this profile; assertion vacuous.\n        return;\n      }\n      const childId = `${parentGrant.id}:probe`;\n      const result = await profile.requestEntitlement({ id: childId });\n      expect(result.outcome).toBe(\"granted\");\n    });\n  });\n}\n",
+    "/**\n * @license\n * Copyright 2026 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { describe, expect, it } from \"vitest\";\n\nimport { OPTIONAL_CREDENTIAL } from \"../fixtures\";\nimport type {\n  EntitlementProfileConformanceHandle,\n  EntitlementProfileConformanceOpts,\n} from \"../types\";\n\n/**\n * Optional entitlements must never be reported as denied — neither by\n * `requestEntitlement` nor by `checkAll`.\n */\nexport function optionalNeverDeniedBlock(\n  _opts: EntitlementProfileConformanceOpts,\n  getHandle: () => EntitlementProfileConformanceHandle\n): void {\n  describe(\"Optional entitlements never denied\", () => {\n    it(\"requestEntitlement returns granted for an optional entitlement\", async () => {\n      const profile = getHandle().profile;\n      const result = await profile.requestEntitlement(OPTIONAL_CREDENTIAL);\n      expect(result.outcome).toBe(\"granted\");\n    });\n\n    it(\"checkAll returns no denials for an optional entitlement even when uncovered\", async () => {\n      const profile = getHandle().profile;\n      const denials = await profile.checkAll({\n        entitlements: [{ id: \"uncovered:optional\", optional: true }],\n      });\n      expect(denials).toEqual([]);\n    });\n  });\n}\n",
+    "/**\n * @license\n * Copyright 2026 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { describe, expect, it } from \"vitest\";\n\nimport { NETWORK_HTTP_REQUIRED, UNCOVERED_FOO } from \"../fixtures\";\nimport type {\n  EntitlementProfileConformanceHandle,\n  EntitlementProfileConformanceOpts,\n} from \"../types\";\n\n/**\n * For the same input, `requestEntitlement` and `checkAll([input])` agree:\n * - granted ↔ empty denial array\n * - denied ↔ single-element denial array with matching reason\n */\nexport function requestEntitlementShapeBlock(\n  _opts: EntitlementProfileConformanceOpts,\n  getHandle: () => EntitlementProfileConformanceHandle\n): void {\n  describe(\"requestEntitlement shape parity with checkAll\", () => {\n    it(\"granted: requestEntitlement and checkAll agree\", async () => {\n      const profile = getHandle().profile;\n      const isCovered = profile\n        .surface()\n        .some((g) => g.id === NETWORK_HTTP_REQUIRED.id && !g.resources);\n      if (!isCovered) return; // assertion vacuous if profile doesn't grant network:http\n      const single = await profile.requestEntitlement(NETWORK_HTTP_REQUIRED);\n      const all = await profile.checkAll({ entitlements: [NETWORK_HTTP_REQUIRED] });\n      expect(single.outcome).toBe(\"granted\");\n      expect(all).toEqual([]);\n    });\n\n    it(\"denied: requestEntitlement and checkAll agree on reason\", async () => {\n      const profile = getHandle().profile;\n      const single = await profile.requestEntitlement(UNCOVERED_FOO);\n      const all = await profile.checkAll({ entitlements: [UNCOVERED_FOO] });\n      expect(single.outcome).toBe(\"denied\");\n      expect(all).toHaveLength(1);\n      if (single.outcome === \"denied\") {\n        expect(all[0]!.reason).toBe(single.denial.reason);\n        // Spec parity: when reason is policy-deny / user-deny, both calls must\n        // return the same matchedRule. default-deny carries no matchedRule.\n        if (single.denial.reason !== \"default-deny\") {\n          expect((all[0]! as { matchedRule?: unknown }).matchedRule).toEqual(\n            (single.denial as { matchedRule?: unknown }).matchedRule\n          );\n        }\n      }\n    });\n  });\n}\n",
+    "/**\n * @license\n * Copyright 2026 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { describe, expect, it } from \"vitest\";\n\nimport { SCOPED_FILESYSTEM_ETC_BAD, SCOPED_FILESYSTEM_TMP_OK } from \"../fixtures\";\nimport type {\n  EntitlementProfileConformanceHandle,\n  EntitlementProfileConformanceOpts,\n} from \"../types\";\n\n/**\n * For a profile that supports resource scoping, build a temporary scoped\n * grant by augmenting the profile is out of scope here — instead we\n * exercise the policy with a known-scoped fixture only when the profile\n * already grants filesystem broadly. When `filesystem` is broadly granted,\n * a scoped read of any resource succeeds. This block additionally verifies\n * that profiles which DO NOT grant filesystem deny a scoped read of\n * `/etc/passwd`.\n */\nexport function resourceScopingBlock(\n  opts: EntitlementProfileConformanceOpts,\n  getHandle: () => EntitlementProfileConformanceHandle\n): void {\n  describe.skipIf(!opts.capabilities.resourceScoping)(\"Resource scoping\", () => {\n    it(\"scoped read succeeds when the profile broadly grants filesystem\", async () => {\n      const profile = getHandle().profile;\n      const hasBroadFilesystem = profile\n        .surface()\n        .some((g) => g.id === \"filesystem\" && !g.resources);\n      if (!hasBroadFilesystem) {\n        // Profile does not broadly grant filesystem; this assertion is vacuous.\n        return;\n      }\n      const result = await profile.requestEntitlement(SCOPED_FILESYSTEM_TMP_OK);\n      expect(result.outcome).toBe(\"granted\");\n    });\n\n    it(\"scoped read fails when the profile does not grant filesystem at all\", async () => {\n      const profile = getHandle().profile;\n      const hasFilesystem = profile\n        .surface()\n        .some((g) => g.id === \"filesystem\" || g.id === \"filesystem:read\");\n      if (hasFilesystem) {\n        return; // not the negative case\n      }\n      const result = await profile.requestEntitlement(SCOPED_FILESYSTEM_ETC_BAD);\n      expect(result.outcome).toBe(\"denied\");\n    });\n  });\n}\n",
+    "/**\n * @license\n * Copyright 2026 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { describe, expect, it } from \"vitest\";\n\nimport type { EntitlementChangeEvent } from \"@workglow/task-graph\";\nimport { NETWORK_HTTP_REQUIRED, UNCOVERED_FOO } from \"../fixtures\";\nimport type {\n  EntitlementProfileConformanceHandle,\n  EntitlementProfileConformanceOpts,\n} from \"../types\";\n\n/**\n * Verify that the profile emits a \"granted\" change event when the signal\n * source emits a grant for a previously-denied entitlement.\n */\nexport function subscribeGrantBlock(\n  opts: EntitlementProfileConformanceOpts,\n  getHandle: () => EntitlementProfileConformanceHandle\n): void {\n  describe.skipIf(!opts.capabilities.mutableSignalSource)(\"Subscribe grant\", () => {\n    it(\"emits granted when previously-denied entitlement becomes granted\", async () => {\n      const handle = getHandle();\n      if (!handle.simulateSignal) {\n        throw new Error(\"simulateSignal must be present when mutableSignalSource is true\");\n      }\n      const events: EntitlementChangeEvent[] = [];\n      const unsub = handle.profile.subscribe((e) => events.push(e));\n      try {\n        // Seed: query an entitlement that is currently denied. The Custom shim's\n        // simulateSignal stages the policy flip before emitting the signal.\n        const before = await handle.profile.requestEntitlement(UNCOVERED_FOO);\n        if (before.outcome !== \"denied\") return; // not the case for this profile\n        handle.simulateSignal({ kind: \"grant\", entitlement: UNCOVERED_FOO });\n        await new Promise((r) => setTimeout(r, 0));\n        const granted = events.find((e) => e.kind === \"granted\");\n        expect(granted).toBeDefined();\n        expect(granted?.entitlement.id).toBe(UNCOVERED_FOO.id);\n      } finally {\n        unsub();\n      }\n    });\n\n    it(\"does not emit when grant signal arrives for already-granted entitlement\", async () => {\n      const handle = getHandle();\n      if (!handle.simulateSignal) return;\n      const events: EntitlementChangeEvent[] = [];\n      const unsub = handle.profile.subscribe((e) => events.push(e));\n      try {\n        // Seed: query an entitlement currently granted by the policy.\n        const before = await handle.profile.requestEntitlement(NETWORK_HTTP_REQUIRED);\n        if (before.outcome !== \"granted\") return; // not the case for this profile\n        handle.simulateSignal({ kind: \"grant\", entitlement: NETWORK_HTTP_REQUIRED });\n        await new Promise((r) => setTimeout(r, 0));\n        expect(events).toEqual([]);\n      } finally {\n        unsub();\n      }\n    });\n  });\n}\n",
+    "/**\n * @license\n * Copyright 2026 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { describe, expect, it } from \"vitest\";\n\nimport type { EntitlementChangeEvent } from \"@workglow/task-graph\";\nimport { NETWORK_HTTP_REQUIRED, UNCOVERED_FOO } from \"../fixtures\";\nimport type {\n  EntitlementProfileConformanceHandle,\n  EntitlementProfileConformanceOpts,\n} from \"../types\";\n\n/**\n * After querying a set of entitlements then signalling reload, change events\n * fire only for entitlements whose verdict actually flipped.\n */\nexport function subscribeReloadBlock(\n  opts: EntitlementProfileConformanceOpts,\n  getHandle: () => EntitlementProfileConformanceHandle\n): void {\n  describe.skipIf(!opts.capabilities.mutableSignalSource)(\"Subscribe reload\", () => {\n    it(\"reload fires events only for previously-queried entitlements that flipped\", async () => {\n      const handle = getHandle();\n      if (!handle.simulateSignal) return;\n      const events: EntitlementChangeEvent[] = [];\n      // Pre-seed by querying two entitlements before subscribing.\n      await handle.profile.requestEntitlement(NETWORK_HTTP_REQUIRED);\n      await handle.profile.requestEntitlement(UNCOVERED_FOO);\n      const unsub = handle.profile.subscribe((e) => events.push(e));\n      try {\n        // The shim's simulateSignal stages a policy mutation that flips\n        // exactly one of the two seeded entitlements before emitting reload.\n        handle.simulateSignal({ kind: \"reload\" });\n        await new Promise((r) => setTimeout(r, 0));\n        // The shim's simulateSignal stages a policy mutation that flips exactly\n        // one of the two seeded entitlements (NETWORK_HTTP) before emitting reload.\n        // A conforming profile emits change events ONLY for entitlements that\n        // actually flipped — never for entitlements whose verdict is unchanged.\n        expect(events.map((e) => e.entitlement.id)).toEqual([NETWORK_HTTP_REQUIRED.id]);\n      } finally {\n        unsub();\n      }\n    });\n  });\n}\n",
+    "/**\n * @license\n * Copyright 2026 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { describe, expect, it } from \"vitest\";\n\nimport type { EntitlementChangeEvent } from \"@workglow/task-graph\";\nimport { NETWORK_HTTP_REQUIRED, UNCOVERED_FOO } from \"../fixtures\";\nimport type {\n  EntitlementProfileConformanceHandle,\n  EntitlementProfileConformanceOpts,\n} from \"../types\";\n\n/**\n * Verify that the profile re-evaluates and emits a \"revoked\" change event\n * when the signal source emits a revoke for a previously-granted\n * entitlement, and emits nothing when no flip occurred.\n */\nexport function subscribeRevocationBlock(\n  opts: EntitlementProfileConformanceOpts,\n  getHandle: () => EntitlementProfileConformanceHandle\n): void {\n  describe.skipIf(!opts.capabilities.mutableSignalSource)(\"Subscribe revocation\", () => {\n    it(\"emits revoked when previously-granted entitlement becomes denied\", async () => {\n      const handle = getHandle();\n      if (!handle.simulateSignal) {\n        throw new Error(\"simulateSignal must be present when mutableSignalSource is true\");\n      }\n      const events: EntitlementChangeEvent[] = [];\n      const unsub = handle.profile.subscribe((e) => events.push(e));\n      try {\n        // Seed: query and confirm currently granted.\n        const before = await handle.profile.requestEntitlement(NETWORK_HTTP_REQUIRED);\n        if (before.outcome !== \"granted\") {\n          // Profile does not grant this; this assertion is vacuous for it.\n          return;\n        }\n        // The Custom_Profile shim's underlying policy mutates so that revoke\n        // signals reflect a real flip; the simulateSignal hook on the shim\n        // is responsible for staging that policy change before emitting.\n        handle.simulateSignal({ kind: \"revoke\", entitlement: NETWORK_HTTP_REQUIRED });\n        await new Promise((r) => setTimeout(r, 0));\n        const revoked = events.find((e) => e.kind === \"revoked\");\n        expect(revoked).toBeDefined();\n        expect(revoked?.entitlement.id).toBe(NETWORK_HTTP_REQUIRED.id);\n      } finally {\n        unsub();\n      }\n    });\n\n    it(\"does not emit when no flip occurs (revoke for never-granted entitlement)\", async () => {\n      const handle = getHandle();\n      if (!handle.simulateSignal) return;\n      const events: EntitlementChangeEvent[] = [];\n      const unsub = handle.profile.subscribe((e) => events.push(e));\n      try {\n        // Query an uncovered entitlement: it's already denied.\n        await handle.profile.requestEntitlement(UNCOVERED_FOO);\n        handle.simulateSignal({ kind: \"revoke\", entitlement: UNCOVERED_FOO });\n        await new Promise((r) => setTimeout(r, 0));\n        expect(events).toEqual([]);\n      } finally {\n        unsub();\n      }\n    });\n  });\n}\n",
+    "/**\n * @license\n * Copyright 2026 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { describe, expect, it } from \"vitest\";\n\nimport { UNCOVERED_FOO } from \"../fixtures\";\nimport type {\n  EntitlementProfileConformanceHandle,\n  EntitlementProfileConformanceOpts,\n} from \"../types\";\n\nexport function surfaceCoverageBlock(\n  opts: EntitlementProfileConformanceOpts,\n  getHandle: () => EntitlementProfileConformanceHandle\n): void {\n  describe(\"Surface coverage\", () => {\n    it(\"surface() includes every entitlement listed in expected.surfaceIncludes\", async () => {\n      const profile = getHandle().profile;\n      const surface = profile.surface().map((g) => g.id);\n      for (const id of opts.expected.surfaceIncludes) {\n        expect(surface).toContain(id);\n      }\n    });\n\n    it(\"surface() excludes every entitlement listed in expected.surfaceExcludes\", async () => {\n      const profile = getHandle().profile;\n      const surface = profile.surface().map((g) => g.id);\n      for (const id of opts.expected.surfaceExcludes) {\n        expect(surface).not.toContain(id);\n      }\n    });\n\n    it(\"requestEntitlement returns granted for an entitlement covered by surface\", async () => {\n      const profile = getHandle().profile;\n      const firstGrant = profile.surface()[0];\n      if (!firstGrant) {\n        // empty surface — assertion vacuous; opts.expected.surfaceIncludes\n        // would have been empty too.\n        return;\n      }\n      const result = await profile.requestEntitlement({ id: firstGrant.id });\n      expect(result.outcome).toBe(\"granted\");\n    });\n\n    it(\"requestEntitlement returns denied with default-deny reason for an uncovered entitlement\", async () => {\n      const profile = getHandle().profile;\n      const result = await profile.requestEntitlement(UNCOVERED_FOO);\n      expect(result.outcome).toBe(\"denied\");\n      if (result.outcome === \"denied\") {\n        expect(result.denial.reason).toBe(\"default-deny\");\n        expect(result.denial.entitlement).toBe(UNCOVERED_FOO);\n      }\n    });\n  });\n}\n",
+    "/**\n * @license\n * Copyright 2026 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { describe, expect, it } from \"vitest\";\n\nimport type { EntitlementChangeEvent } from \"@workglow/task-graph\";\nimport { NETWORK_HTTP_REQUIRED } from \"../fixtures\";\nimport type {\n  EntitlementProfileConformanceHandle,\n  EntitlementProfileConformanceOpts,\n} from \"../types\";\n\nexport function unsubscribeIdempotentBlock(\n  opts: EntitlementProfileConformanceOpts,\n  getHandle: () => EntitlementProfileConformanceHandle\n): void {\n  describe.skipIf(!opts.capabilities.mutableSignalSource)(\"Unsubscribe idempotent\", () => {\n    it(\"calling unsubscribe twice does not throw\", () => {\n      const profile = getHandle().profile;\n      const unsub = profile.subscribe(() => {});\n      unsub();\n      expect(() => unsub()).not.toThrow();\n    });\n\n    it(\"after unsubscribe, no further events are delivered\", async () => {\n      const handle = getHandle();\n      if (!handle.simulateSignal) return;\n      const events: EntitlementChangeEvent[] = [];\n      const unsub = handle.profile.subscribe((e) => events.push(e));\n      // Seed and unsub before signalling.\n      await handle.profile.requestEntitlement(NETWORK_HTTP_REQUIRED);\n      unsub();\n      handle.simulateSignal({ kind: \"revoke\", entitlement: NETWORK_HTTP_REQUIRED });\n      await new Promise((r) => setTimeout(r, 0));\n      expect(events).toEqual([]);\n    });\n  });\n}\n"
+  ],
+  "mappings": ";AAMA;AAAA;AAAA;AAOO,IAAM,wBAAyC;AAAA,EACpD,IAAI,aAAa;AAAA,EACjB,QAAQ;AACV;AAEO,IAAM,sBAAuC;AAAA,EAClD,IAAI,aAAa;AAAA,EACjB,QAAQ;AACV;AAEO,IAAM,sBAAuC;AAAA,EAClD,IAAI,aAAa;AAAA,EACjB,QAAQ;AAAA,EACR,UAAU;AACZ;AAEO,IAAM,2BAA4C;AAAA,EACvD,IAAI,aAAa;AAAA,EACjB,QAAQ;AAAA,EACR,WAAW,CAAC,gBAAgB;AAC9B;AAEO,IAAM,4BAA6C;AAAA,EACxD,IAAI,aAAa;AAAA,EACjB,QAAQ;AAAA,EACR,WAAW,CAAC,aAAa;AAC3B;AAGO,IAAM,gBAAiC;AAAA,EAC5C,IAAI;AAAA,EACJ,QAAQ;AACV;AAUO,SAAS,8BAA8B,GAA6B;AAAA,EACzE,MAAM,YAAY,IAAI;AAAA,EACtB,OAAO;AAAA,IACL,SAAS,CAAC,UAAU;AAAA,MAClB,UAAU,IAAI,QAAQ;AAAA,MACtB,IAAI,WAAW;AAAA,MACf,OAAO,MAAM;AAAA,QACX,IAAI;AAAA,UAAU;AAAA,QACd,WAAW;AAAA,QACX,UAAU,OAAO,QAAQ;AAAA;AAAA;AAAA,IAG7B,IAAI,CAAC,QAAQ;AAAA,MACX,WAAW,KAAK;AAAA,QAAW,EAAE,MAAM;AAAA;AAAA,EAEvC;AAAA;;AChEF,0CAA8B;;;ACA9B;AAcO,SAAS,gBAAgB,CAC9B,OACA,WACM;AAAA,EACN,SAAS,gBAAgB,MAAM;AAAA,IAC7B,GAAG,sEAAsE,YAAY;AAAA,MACnF,MAAM,UAAU,UAAU,EAAE;AAAA,MAC5B,MAAM,SAAS,MAAM,QAAQ,mBAAmB,aAAa;AAAA,MAC7D,OAAO,OAAO,OAAO,EAAE,KAAK,QAAQ;AAAA,MACpC,IAAI,OAAO,YAAY,UAAU;AAAA,QAC/B,OAAO,OAAO,OAAO,WAAW,EAAE,KAAK,aAAa;AAAA,MACtD;AAAA,KACD;AAAA,IAED,GAAG,2DAA2D,YAAY;AAAA,MACxE,MAAM,UAAU,UAAU,EAAE;AAAA,MAC5B,MAAM,SAAS,MAAM,QAAQ,mBAAmB,aAAa;AAAA,MAC7D,IAAI,OAAO,YAAY,UAAU;AAAA,QAC/B,OAAO,CAAC,eAAe,gBAAgB,WAAW,CAAC,EAAE,UAAU,OAAO,OAAO,MAAM;AAAA,MACrF;AAAA,KACD;AAAA,IAED,GAAG,sEAAsE,YAAY;AAAA,MACnF,MAAM,UAAU,UAAU,EAAE;AAAA,MAC5B,MAAM,SAAS,MAAM,QAAQ,mBAAmB,aAAa;AAAA,MAC7D,IAAI,OAAO,YAAY,UAAU;AAAA,QAC/B,MAAM,IAAI,OAAO;AAAA,QACjB,IAAI,EAAE,WAAW,gBAAgB;AAAA,UAE/B,OAAO,iBAAiB,CAAC,EAAE,KAAK,KAAK;AAAA,QACvC,EAAO;AAAA,UAEL,OAAO,EAAE,WAAW,EAAE,YAAY;AAAA;AAAA,MAEtC;AAAA,KACD;AAAA,GACF;AAAA;;;AClDH,qBAAS,qBAAU,eAAQ;AAkBpB,SAAS,YAAY,CAC1B,MACA,YACM;AAAA,EACN,UAAS,WAAW,MAAM;AAAA,IACxB,IAAG,6CAA6C,YAAY;AAAA,MAC1D,MAAM,QAAQ,MAAM,KAAK,QAAQ;AAAA,MACjC,IAAI;AAAA,QACF,MAAM,MAAM,QAAQ,QAAQ;AAAA,QAC5B,MAAM,QAAO,MAAM,QAAQ,QAAQ,CAAC,EAAE,SAAS,cAAc;AAAA,gBAC7D;AAAA,QAEA,MAAM,MAAM,QAAQ;AAAA;AAAA,KAEvB;AAAA,IAED,IAAG,OAAO,CAAC,KAAK,aAAa,mBAAmB,EAC9C,wDACA,YAAY;AAAA,MACV,MAAM,QAAQ,MAAM,KAAK,QAAQ;AAAA,MACjC,IAAI;AAAA,QACF,IAAI,CAAC,MAAM;AAAA,UAAgB;AAAA,QAC3B,MAAM,SAAmC,CAAC;AAAA,QAC1C,MAAM,QAAQ,UAAU,CAAC,MAAM,OAAO,KAAK,CAAC,CAAC;AAAA,QAC7C,MAAM,MAAM,QAAQ,mBAAmB,qBAAqB;AAAA,QAC5D,MAAM,MAAM,QAAQ,QAAQ;AAAA,QAC5B,MAAM,eAAe,EAAE,MAAM,UAAU,aAAa,sBAAsB,CAAC;AAAA,QAC3E,MAAM,IAAI,QAAQ,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC;AAAA,QACzC,QAAO,MAAM,EAAE,QAAQ,CAAC,CAAC;AAAA,gBACzB;AAAA,QACA,MAAM,MAAM,QAAQ;AAAA;AAAA,KAG1B;AAAA,GACD;AAAA;;;ACpDH,qBAAS,qBAAU,eAAQ;AAWpB,SAAS,sBAAsB,CACpC,MACA,WACM;AAAA,EACN,UAAS,OAAO,CAAC,KAAK,aAAa,iBAAiB,EAAE,sBAAsB,MAAM;AAAA,IAChF,IAAG,0DAA0D,YAAY;AAAA,MACvE,MAAM,UAAU,UAAU,EAAE;AAAA,MAE5B,MAAM,cAAc,QAAQ,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,GAAG,SAAS,GAAG,KAAK,CAAC,EAAE,SAAS;AAAA,MACrF,IAAI,CAAC,aAAa;AAAA,QAEhB;AAAA,MACF;AAAA,MACA,MAAM,UAAU,GAAG,YAAY;AAAA,MAC/B,MAAM,SAAS,MAAM,QAAQ,mBAAmB,EAAE,IAAI,QAAQ,CAAC;AAAA,MAC/D,QAAO,OAAO,OAAO,EAAE,KAAK,SAAS;AAAA,KACtC;AAAA,GACF;AAAA;;;AC5BH,qBAAS,qBAAU,eAAQ;AAYpB,SAAS,wBAAwB,CACtC,OACA,WACM;AAAA,EACN,UAAS,sCAAsC,MAAM;AAAA,IACnD,IAAG,kEAAkE,YAAY;AAAA,MAC/E,MAAM,UAAU,UAAU,EAAE;AAAA,MAC5B,MAAM,SAAS,MAAM,QAAQ,mBAAmB,mBAAmB;AAAA,MACnE,QAAO,OAAO,OAAO,EAAE,KAAK,SAAS;AAAA,KACtC;AAAA,IAED,IAAG,+EAA+E,YAAY;AAAA,MAC5F,MAAM,UAAU,UAAU,EAAE;AAAA,MAC5B,MAAM,UAAU,MAAM,QAAQ,SAAS;AAAA,QACrC,cAAc,CAAC,EAAE,IAAI,sBAAsB,UAAU,KAAK,CAAC;AAAA,MAC7D,CAAC;AAAA,MACD,QAAO,OAAO,EAAE,QAAQ,CAAC,CAAC;AAAA,KAC3B;AAAA,GACF;AAAA;;;AC9BH,qBAAS,qBAAU,eAAQ;AAapB,SAAS,4BAA4B,CAC1C,OACA,WACM;AAAA,EACN,UAAS,iDAAiD,MAAM;AAAA,IAC9D,IAAG,kDAAkD,YAAY;AAAA,MAC/D,MAAM,UAAU,UAAU,EAAE;AAAA,MAC5B,MAAM,YAAY,QACf,QAAQ,EACR,KAAK,CAAC,MAAM,EAAE,OAAO,sBAAsB,MAAM,CAAC,EAAE,SAAS;AAAA,MAChE,IAAI,CAAC;AAAA,QAAW;AAAA,MAChB,MAAM,SAAS,MAAM,QAAQ,mBAAmB,qBAAqB;AAAA,MACrE,MAAM,MAAM,MAAM,QAAQ,SAAS,EAAE,cAAc,CAAC,qBAAqB,EAAE,CAAC;AAAA,MAC5E,QAAO,OAAO,OAAO,EAAE,KAAK,SAAS;AAAA,MACrC,QAAO,GAAG,EAAE,QAAQ,CAAC,CAAC;AAAA,KACvB;AAAA,IAED,IAAG,2DAA2D,YAAY;AAAA,MACxE,MAAM,UAAU,UAAU,EAAE;AAAA,MAC5B,MAAM,SAAS,MAAM,QAAQ,mBAAmB,aAAa;AAAA,MAC7D,MAAM,MAAM,MAAM,QAAQ,SAAS,EAAE,cAAc,CAAC,aAAa,EAAE,CAAC;AAAA,MACpE,QAAO,OAAO,OAAO,EAAE,KAAK,QAAQ;AAAA,MACpC,QAAO,GAAG,EAAE,aAAa,CAAC;AAAA,MAC1B,IAAI,OAAO,YAAY,UAAU;AAAA,QAC/B,QAAO,IAAI,GAAI,MAAM,EAAE,KAAK,OAAO,OAAO,MAAM;AAAA,QAGhD,IAAI,OAAO,OAAO,WAAW,gBAAgB;AAAA,UAC3C,QAAQ,IAAI,GAAkC,WAAW,EAAE,QACxD,OAAO,OAAqC,WAC/C;AAAA,QACF;AAAA,MACF;AAAA,KACD;AAAA,GACF;AAAA;;;AC/CH,qBAAS,qBAAU,eAAQ;AAiBpB,SAAS,oBAAoB,CAClC,MACA,WACM;AAAA,EACN,UAAS,OAAO,CAAC,KAAK,aAAa,eAAe,EAAE,oBAAoB,MAAM;AAAA,IAC5E,IAAG,mEAAmE,YAAY;AAAA,MAChF,MAAM,UAAU,UAAU,EAAE;AAAA,MAC5B,MAAM,qBAAqB,QACxB,QAAQ,EACR,KAAK,CAAC,MAAM,EAAE,OAAO,gBAAgB,CAAC,EAAE,SAAS;AAAA,MACpD,IAAI,CAAC,oBAAoB;AAAA,QAEvB;AAAA,MACF;AAAA,MACA,MAAM,SAAS,MAAM,QAAQ,mBAAmB,wBAAwB;AAAA,MACxE,QAAO,OAAO,OAAO,EAAE,KAAK,SAAS;AAAA,KACtC;AAAA,IAED,IAAG,uEAAuE,YAAY;AAAA,MACpF,MAAM,UAAU,UAAU,EAAE;AAAA,MAC5B,MAAM,gBAAgB,QACnB,QAAQ,EACR,KAAK,CAAC,MAAM,EAAE,OAAO,gBAAgB,EAAE,OAAO,iBAAiB;AAAA,MAClE,IAAI,eAAe;AAAA,QACjB;AAAA,MACF;AAAA,MACA,MAAM,SAAS,MAAM,QAAQ,mBAAmB,yBAAyB;AAAA,MACzE,QAAO,OAAO,OAAO,EAAE,KAAK,QAAQ;AAAA,KACrC;AAAA,GACF;AAAA;;;AC9CH,qBAAS,qBAAU,eAAQ;AAapB,SAAS,mBAAmB,CACjC,MACA,WACM;AAAA,EACN,UAAS,OAAO,CAAC,KAAK,aAAa,mBAAmB,EAAE,mBAAmB,MAAM;AAAA,IAC/E,IAAG,oEAAoE,YAAY;AAAA,MACjF,MAAM,SAAS,UAAU;AAAA,MACzB,IAAI,CAAC,OAAO,gBAAgB;AAAA,QAC1B,MAAM,IAAI,MAAM,iEAAiE;AAAA,MACnF;AAAA,MACA,MAAM,SAAmC,CAAC;AAAA,MAC1C,MAAM,QAAQ,OAAO,QAAQ,UAAU,CAAC,MAAM,OAAO,KAAK,CAAC,CAAC;AAAA,MAC5D,IAAI;AAAA,QAGF,MAAM,SAAS,MAAM,OAAO,QAAQ,mBAAmB,aAAa;AAAA,QACpE,IAAI,OAAO,YAAY;AAAA,UAAU;AAAA,QACjC,OAAO,eAAe,EAAE,MAAM,SAAS,aAAa,cAAc,CAAC;AAAA,QACnE,MAAM,IAAI,QAAQ,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC;AAAA,QACzC,MAAM,UAAU,OAAO,KAAK,CAAC,MAAM,EAAE,SAAS,SAAS;AAAA,QACvD,QAAO,OAAO,EAAE,YAAY;AAAA,QAC5B,QAAO,SAAS,YAAY,EAAE,EAAE,KAAK,cAAc,EAAE;AAAA,gBACrD;AAAA,QACA,MAAM;AAAA;AAAA,KAET;AAAA,IAED,IAAG,2EAA2E,YAAY;AAAA,MACxF,MAAM,SAAS,UAAU;AAAA,MACzB,IAAI,CAAC,OAAO;AAAA,QAAgB;AAAA,MAC5B,MAAM,SAAmC,CAAC;AAAA,MAC1C,MAAM,QAAQ,OAAO,QAAQ,UAAU,CAAC,MAAM,OAAO,KAAK,CAAC,CAAC;AAAA,MAC5D,IAAI;AAAA,QAEF,MAAM,SAAS,MAAM,OAAO,QAAQ,mBAAmB,qBAAqB;AAAA,QAC5E,IAAI,OAAO,YAAY;AAAA,UAAW;AAAA,QAClC,OAAO,eAAe,EAAE,MAAM,SAAS,aAAa,sBAAsB,CAAC;AAAA,QAC3E,MAAM,IAAI,QAAQ,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC;AAAA,QACzC,QAAO,MAAM,EAAE,QAAQ,CAAC,CAAC;AAAA,gBACzB;AAAA,QACA,MAAM;AAAA;AAAA,KAET;AAAA,GACF;AAAA;;;ACxDH,qBAAS,qBAAU,eAAQ;AAapB,SAAS,oBAAoB,CAClC,MACA,WACM;AAAA,EACN,UAAS,OAAO,CAAC,KAAK,aAAa,mBAAmB,EAAE,oBAAoB,MAAM;AAAA,IAChF,IAAG,6EAA6E,YAAY;AAAA,MAC1F,MAAM,SAAS,UAAU;AAAA,MACzB,IAAI,CAAC,OAAO;AAAA,QAAgB;AAAA,MAC5B,MAAM,SAAmC,CAAC;AAAA,MAE1C,MAAM,OAAO,QAAQ,mBAAmB,qBAAqB;AAAA,MAC7D,MAAM,OAAO,QAAQ,mBAAmB,aAAa;AAAA,MACrD,MAAM,QAAQ,OAAO,QAAQ,UAAU,CAAC,MAAM,OAAO,KAAK,CAAC,CAAC;AAAA,MAC5D,IAAI;AAAA,QAGF,OAAO,eAAe,EAAE,MAAM,SAAS,CAAC;AAAA,QACxC,MAAM,IAAI,QAAQ,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC;AAAA,QAKzC,QAAO,OAAO,IAAI,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,EAAE,QAAQ,CAAC,sBAAsB,EAAE,CAAC;AAAA,gBAC9E;AAAA,QACA,MAAM;AAAA;AAAA,KAET;AAAA,GACF;AAAA;;;ACxCH,qBAAS,qBAAU,eAAQ;AAcpB,SAAS,wBAAwB,CACtC,MACA,WACM;AAAA,EACN,UAAS,OAAO,CAAC,KAAK,aAAa,mBAAmB,EAAE,wBAAwB,MAAM;AAAA,IACpF,IAAG,oEAAoE,YAAY;AAAA,MACjF,MAAM,SAAS,UAAU;AAAA,MACzB,IAAI,CAAC,OAAO,gBAAgB;AAAA,QAC1B,MAAM,IAAI,MAAM,iEAAiE;AAAA,MACnF;AAAA,MACA,MAAM,SAAmC,CAAC;AAAA,MAC1C,MAAM,QAAQ,OAAO,QAAQ,UAAU,CAAC,MAAM,OAAO,KAAK,CAAC,CAAC;AAAA,MAC5D,IAAI;AAAA,QAEF,MAAM,SAAS,MAAM,OAAO,QAAQ,mBAAmB,qBAAqB;AAAA,QAC5E,IAAI,OAAO,YAAY,WAAW;AAAA,UAEhC;AAAA,QACF;AAAA,QAIA,OAAO,eAAe,EAAE,MAAM,UAAU,aAAa,sBAAsB,CAAC;AAAA,QAC5E,MAAM,IAAI,QAAQ,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC;AAAA,QACzC,MAAM,UAAU,OAAO,KAAK,CAAC,MAAM,EAAE,SAAS,SAAS;AAAA,QACvD,QAAO,OAAO,EAAE,YAAY;AAAA,QAC5B,QAAO,SAAS,YAAY,EAAE,EAAE,KAAK,sBAAsB,EAAE;AAAA,gBAC7D;AAAA,QACA,MAAM;AAAA;AAAA,KAET;AAAA,IAED,IAAG,4EAA4E,YAAY;AAAA,MACzF,MAAM,SAAS,UAAU;AAAA,MACzB,IAAI,CAAC,OAAO;AAAA,QAAgB;AAAA,MAC5B,MAAM,SAAmC,CAAC;AAAA,MAC1C,MAAM,QAAQ,OAAO,QAAQ,UAAU,CAAC,MAAM,OAAO,KAAK,CAAC,CAAC;AAAA,MAC5D,IAAI;AAAA,QAEF,MAAM,OAAO,QAAQ,mBAAmB,aAAa;AAAA,QACrD,OAAO,eAAe,EAAE,MAAM,UAAU,aAAa,cAAc,CAAC;AAAA,QACpE,MAAM,IAAI,QAAQ,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC;AAAA,QACzC,QAAO,MAAM,EAAE,QAAQ,CAAC,CAAC;AAAA,gBACzB;AAAA,QACA,MAAM;AAAA;AAAA,KAET;AAAA,GACF;AAAA;;;AC7DH,qBAAS,sBAAU,gBAAQ;AAQpB,SAAS,oBAAoB,CAClC,MACA,WACM;AAAA,EACN,WAAS,oBAAoB,MAAM;AAAA,IACjC,KAAG,2EAA2E,YAAY;AAAA,MACxF,MAAM,UAAU,UAAU,EAAE;AAAA,MAC5B,MAAM,UAAU,QAAQ,QAAQ,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE;AAAA,MACjD,WAAW,MAAM,KAAK,SAAS,iBAAiB;AAAA,QAC9C,SAAO,OAAO,EAAE,UAAU,EAAE;AAAA,MAC9B;AAAA,KACD;AAAA,IAED,KAAG,2EAA2E,YAAY;AAAA,MACxF,MAAM,UAAU,UAAU,EAAE;AAAA,MAC5B,MAAM,UAAU,QAAQ,QAAQ,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE;AAAA,MACjD,WAAW,MAAM,KAAK,SAAS,iBAAiB;AAAA,QAC9C,SAAO,OAAO,EAAE,IAAI,UAAU,EAAE;AAAA,MAClC;AAAA,KACD;AAAA,IAED,KAAG,4EAA4E,YAAY;AAAA,MACzF,MAAM,UAAU,UAAU,EAAE;AAAA,MAC5B,MAAM,aAAa,QAAQ,QAAQ,EAAE;AAAA,MACrC,IAAI,CAAC,YAAY;AAAA,QAGf;AAAA,MACF;AAAA,MACA,MAAM,SAAS,MAAM,QAAQ,mBAAmB,EAAE,IAAI,WAAW,GAAG,CAAC;AAAA,MACrE,SAAO,OAAO,OAAO,EAAE,KAAK,SAAS;AAAA,KACtC;AAAA,IAED,KAAG,2FAA2F,YAAY;AAAA,MACxG,MAAM,UAAU,UAAU,EAAE;AAAA,MAC5B,MAAM,SAAS,MAAM,QAAQ,mBAAmB,aAAa;AAAA,MAC7D,SAAO,OAAO,OAAO,EAAE,KAAK,QAAQ;AAAA,MACpC,IAAI,OAAO,YAAY,UAAU;AAAA,QAC/B,SAAO,OAAO,OAAO,MAAM,EAAE,KAAK,cAAc;AAAA,QAChD,SAAO,OAAO,OAAO,WAAW,EAAE,KAAK,aAAa;AAAA,MACtD;AAAA,KACD;AAAA,GACF;AAAA;;;AClDH,qBAAS,sBAAU,gBAAQ;AASpB,SAAS,0BAA0B,CACxC,MACA,WACM;AAAA,EACN,WAAS,OAAO,CAAC,KAAK,aAAa,mBAAmB,EAAE,0BAA0B,MAAM;AAAA,IACtF,KAAG,4CAA4C,MAAM;AAAA,MACnD,MAAM,UAAU,UAAU,EAAE;AAAA,MAC5B,MAAM,QAAQ,QAAQ,UAAU,MAAM,EAAE;AAAA,MACxC,MAAM;AAAA,MACN,SAAO,MAAM,MAAM,CAAC,EAAE,IAAI,QAAQ;AAAA,KACnC;AAAA,IAED,KAAG,sDAAsD,YAAY;AAAA,MACnE,MAAM,SAAS,UAAU;AAAA,MACzB,IAAI,CAAC,OAAO;AAAA,QAAgB;AAAA,MAC5B,MAAM,SAAmC,CAAC;AAAA,MAC1C,MAAM,QAAQ,OAAO,QAAQ,UAAU,CAAC,MAAM,OAAO,KAAK,CAAC,CAAC;AAAA,MAE5D,MAAM,OAAO,QAAQ,mBAAmB,qBAAqB;AAAA,MAC7D,MAAM;AAAA,MACN,OAAO,eAAe,EAAE,MAAM,UAAU,aAAa,sBAAsB,CAAC;AAAA,MAC5E,MAAM,IAAI,QAAQ,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC;AAAA,MACzC,SAAO,MAAM,EAAE,QAAQ,CAAC,CAAC;AAAA,KAC1B;AAAA,GACF;AAAA;;;AXfI,SAAS,gCAAgC,CAAC,MAA+C;AAAA,EAC9F,WAAS,OAAO,KAAK,IAAI,EAAE,mCAAmC,KAAK,QAAQ,MAAM;AAAA,IAC/E,IAAI;AAAA,IACJ,MAAM,YAAY,MAA2C;AAAA,MAC3D,IAAI,CAAC;AAAA,QAAQ,MAAM,IAAI,MAAM,oCAAoC;AAAA,MACjE,OAAO;AAAA;AAAA,IAGT,UAAU,YAAY;AAAA,MACpB,SAAS,MAAM,KAAK,QAAQ;AAAA,OAC3B,KAAK,OAAO;AAAA,IAEf,SAAS,YAAY;AAAA,MACnB,IAAI;AAAA,QAAQ,MAAM,OAAO,QAAQ;AAAA,KAClC;AAAA,IAGD,qBAAqB,MAAM,SAAS;AAAA,IACpC,uBAAuB,MAAM,SAAS;AAAA,IACtC,qBAAqB,MAAM,SAAS;AAAA,IACpC,yBAAyB,MAAM,SAAS;AAAA,IACxC,iBAAiB,MAAM,SAAS;AAAA,IAChC,6BAA6B,MAAM,SAAS;AAAA,IAC5C,yBAAyB,MAAM,SAAS;AAAA,IACxC,oBAAoB,MAAM,SAAS;AAAA,IACnC,qBAAqB,MAAM,SAAS;AAAA,IACpC,2BAA2B,MAAM,SAAS;AAAA,IAC1C,aAAa,MAAM,SAAS;AAAA,GAC7B;AAAA;",
+  "debugId": "A4B432BFC9E613D164756E2164756E21",
+  "names": []
+}

package/dist/human-connector/MockHumanConnector.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2026 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { HumanResponseAction, IHumanConnector, IHumanRequest, IHumanResponse } from "@workglow/util";
+import type { MockResponseScript } from "./types";
+export interface MockHumanConnectorOpts {
+    /** Default action when no script entry is queued. Defaults to "accept". */
+    readonly defaultAction?: HumanResponseAction;
+    /** Whether `followUp` is implemented. Defaults to true. */
+    readonly supportsFollowUp?: boolean;
+}
+export declare class MockHumanConnector implements IHumanConnector {
+    private readonly defaultAction;
+    private readonly _script;
+    readonly followUp?: (request: IHumanRequest, previous: IHumanResponse, signal: AbortSignal) => Promise<IHumanResponse>;
+    constructor(opts?: MockHumanConnectorOpts);
+    get script(): MockResponseScript;
+    send(request: IHumanRequest, signal: AbortSignal): Promise<IHumanResponse>;
+    /**
+     * Content belongs to an accepted elicit and nothing else, whatever a script
+     * put beside the action — the reference connector holds the same contract
+     * every adapter is measured against. A confirm answers with the decision
+     * alone, and a refused elicit answers with no data, since `HumanInputTask`
+     * spreads `content` onto its output ports either way.
+     */
+    private shape;
+}

package/dist/human-connector/assertions/abort.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ConformanceFixture, HumanConnectorConformanceHandle, HumanConnectorConformanceOpts } from "../types";
+export declare function abortBlock(opts: HumanConnectorConformanceOpts, fixture: ConformanceFixture, getHandle: () => HumanConnectorConformanceHandle): void;

package/dist/human-connector/assertions/capabilityHonesty.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ConformanceFixture, HumanConnectorConformanceHandle, HumanConnectorConformanceOpts } from "../types";
+export declare function capabilityHonestyBlock(opts: HumanConnectorConformanceOpts, fixture: ConformanceFixture, getHandle: () => HumanConnectorConformanceHandle): void;

package/dist/human-connector/assertions/concurrentIsolation.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ConformanceFixture, HumanConnectorConformanceHandle, HumanConnectorConformanceOpts } from "../types";
+export declare function concurrentIsolationBlock(opts: HumanConnectorConformanceOpts, fixture: ConformanceFixture, getHandle: () => HumanConnectorConformanceHandle): void;

package/dist/human-connector/assertions/multiTurnFollowUp.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ConformanceFixture, HumanConnectorConformanceHandle, HumanConnectorConformanceOpts } from "../types";
+export declare function multiTurnFollowUpBlock(opts: HumanConnectorConformanceOpts, fixture: ConformanceFixture, getHandle: () => HumanConnectorConformanceHandle): void;

package/dist/human-connector/assertions/notifyDisplayFastResolve.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ConformanceFixture, HumanConnectorConformanceHandle, HumanConnectorConformanceOpts } from "../types";
+export declare function notifyDisplayFastResolveBlock(opts: HumanConnectorConformanceOpts, fixture: ConformanceFixture, getHandle: () => HumanConnectorConformanceHandle): void;

package/dist/human-connector/assertions/roundtrip.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ConformanceFixture, HumanConnectorConformanceHandle, HumanConnectorConformanceOpts } from "../types";
+export declare function roundtripBlock(opts: HumanConnectorConformanceOpts, fixture: ConformanceFixture, getHandle: () => HumanConnectorConformanceHandle): void;

package/dist/human-connector/fixtures.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2026 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ConformanceFixture } from "./types";
+export declare const DEFAULT_HUMAN_CONFORMANCE_FIXTURE: ConformanceFixture;
+export declare function resolveHumanConformanceFixture(override: Partial<ConformanceFixture> | undefined): ConformanceFixture;

package/dist/human-connector/runHumanConnectorConformance.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2026 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { HumanConnectorConformanceOpts } from "./types";
+export { MockHumanConnector } from "./MockHumanConnector";
+export type { HumanConnectorConformanceOpts } from "./types";
+export declare function runHumanConnectorConformance(opts: HumanConnectorConformanceOpts): void;