lael-labs/t3code

packages/plugin-runtime-poc/README.md+16−15

@@ -21,9 +21,9 @@ it also fits t3's existing effect runtime. adding cordis did not remove the need · 20 unmodified lines
21		21
22	\| variant \| source lines \| new runtime dependency \| result \|	22	\| variant \| source lines \| new runtime dependency \| result \|
23	\| ----------------------- \| -----------: \| --------------------------------------------------- \| ------------------------------------------------------------------ \|	23	\| ----------------------- \| -----------: \| --------------------------------------------------- \| ------------------------------------------------------------------ \|
24	\| `effectScopeRuntime.ts` \| 376 \| none, effect is already used by t3 \| best base for production \|	24	\| `effectScopeRuntime.ts` \| 407 \| none, effect is already used by t3 \| best base for production \|
25	\| `cordisRuntime.ts` \| 472 \| cordis rc.8 and about 300 kib of installed packages \| works, but adds a second lifecycle runtime and the largest adapter \|	25	\| `cordisRuntime.ts` \| 493 \| cordis rc.8 and about 300 kib of installed packages \| works, but adds a second lifecycle runtime and the largest adapter \|
26	\| `pureRuntime.ts` \| 378 \| none \| simplest planner, but manual finalizers are too easy to misuse \|	26	\| `pureRuntime.ts` \| 394 \| none \| simplest planner, but manual finalizers are too easy to misuse \|
27		27
28	`cordisRuntime.ts` uses real cordis `Context`, `Fiber`, `inject`, `provide`, `effect`, and `isolate` behavior. it still needs its own graph analysis and differential reconciliation so unchanged fibers survive an update and failed candidates never replace the live composition.	28	`cordisRuntime.ts` uses real cordis `Context`, `Fiber`, `inject`, `provide`, `effect`, and `isolate` behavior. it still needs its own graph analysis and differential reconciliation so unchanged fibers survive an update and failed candidates never replace the live composition.
29		29
@@ -31,24 +31,25 @@ cordis `4.0.0-rc.8` also ships extensionless declaration re-exports that do not · 1 unmodified line
31		31
32	## behavior proved	32	## behavior proved
33		33
34	all variants run the same contract suite. the full package currently has 44 tests. it checks:	34	all variants run the same contract suite. the full package currently has 57 tests. it checks:
35		35
36	- dependency-first activation from unordered manifests	36	- dependency-first activation from unordered manifests
37	- blocked plugins when required capabilities are missing	37	- blocked plugins when required capabilities are missing
38	- dependent-first teardown	38	- dependent-first teardown
39	- lifo plugin finalizers	39	- lifo plugin finalizers
40	- no restart for unchanged plugin scopes	40	- no restart for unchanged plugin scopes or reordered dependency declarations
41	- provider changes restart only transitive dependents	41	- targeted restart when versions, provided values, or activation implementations change
42	- provided service identity changes restart providers and dependents	42	- transitive dependent restart without touching unrelated plugins
43	- failed replacement keeps the old composition active	43	- preflight rejection for duplicate ids, duplicate capabilities, and dependency cycles
44	- cleanup attempts every plugin even when a finalizer fails	44	- immutable detached snapshots with prototype-safe plugin ids and contribution slots
45	- dependency cycles fail before activation	45	- rollback that preserves both the active composition and the original activation error
46	- plugin ids and contribution slots cannot collide with object prototype names	46	- cleanup error reporting without rejecting an already committed replacement
		47	- lifecycle events only for committed plugin compositions
47	- deeply frozen public snapshots	48	- deeply frozen public snapshots
48		49
49	the pure planner also proves a 20,000-plugin dependency chain without recursive stack overflow.	50	the pure planner also proves a 20,000-plugin dependency chain without recursive stack overflow.
50		51
51	`manifest.ts` validates namespaced ids, semantic versions, versioned capabilities, permissions, surfaces, and declarative contributions. executable entry points are limited to server, web, and desktop. a mobile javascript entry point is rejected instead of silently ignored.	52	`manifest.ts` validates namespaced ids, semver 2.0.0 versions, versioned capabilities, permissions, surfaces, and declarative contributions. executable entry points are limited to server, web, and desktop and cannot escape the plugin directory through `..` segments. a mobile javascript entry point is rejected instead of silently ignored.
52		53
53	## illustrative timings	54	## illustrative timings
54		55
@@ -56,9 +57,9 @@ five runs used node `24.13.1`. each run activated a chain of 250 plugins, reconc · 1 unmodified line
56		57
57	\| variant \| activate 250 \| unchanged reconcile \| restart 250 \|	58	\| variant \| activate 250 \| unchanged reconcile \| restart 250 \|
58	\| --------------- \| -----------: \| ------------------: \| ----------: \|	59	\| --------------- \| -----------: \| ------------------: \| ----------: \|
59	\| effect scope \| 5.61 ms \| 1.17 ms \| 4.74 ms \|	60	\| effect scope \| 5.44 ms \| 1.16 ms \| 4.31 ms \|
60	\| cordis \| 100.9 ms \| 1.31 ms \| 304.89 ms \|	61	\| direct cordis \| 111.44 ms \| 1.31 ms \| 333.40 ms \|
61	\| pure reconciler \| 0.71 ms \| 0.51 ms \| 0.65 ms \|	62	\| pure reconciler \| 0.74 ms \| 0.59 ms \| 0.69 ms \|
62		63
63	all three produced the same contributions before and after a provider upgrade.	64	all three produced the same contributions before and after a provider upgrade.
64		65

packages/plugin-runtime-poc/src/contract.ts+6−2

 export interface PluginRuntimeSnapshot {
   readonly active: ReadonlyArray<string>;
-  readonly blocked: Readonly<Record<string, string>>;
+  readonly blocked: Readonly<Partial<Record<string, string>>>;
-  readonly contributions: Readonly<Record<string, ReadonlyArray<Contribution>>>;
+  readonly contributions: Readonly<Partial<Record<string, ReadonlyArray<Contribution>>>>;
 }
 export interface PluginRuntime {
     readonly phase: "activate" | "deactivate";
     readonly pluginId: string;
   }) => void;
+  readonly onCleanupError?: (event: {
+    readonly phase: "retire" | "rollback";
+    readonly error: unknown;
+  }) => void;
 }
 export type PluginRuntimeFactory = (options?: PluginRuntimeOptions) => PluginRuntime;

packages/plugin-runtime-poc/src/cordisRuntime.ts+52−35

   };
 }
-function sameStrings(left: ReadonlyArray<string>, right: ReadonlyArray<string>) {
+function sameStringsUnordered(left: ReadonlyArray<string>, right: ReadonlyArray<string>) {
-  return left.length === right.length && left.every((value, index) => value === right[index]);
+  if (left.length !== right.length) return false;
+  const sortedLeft = left.toSorted();
+  const sortedRight = right.toSorted();
+  return sortedLeft.every((value, index) => value === sortedRight[index]);
 }
 function sameDefinition(left: PluginDefinition, right: PluginDefinition) {
-  const leftProvides = Object.entries(left.provides ?? {});
+  const leftProvides = left.provides ?? {};
-  const rightProvides = Object.entries(right.provides ?? {});
+  const rightProvides = right.provides ?? {};
+  const leftCapabilities = Object.keys(leftProvides);
+  const rightCapabilities = Object.keys(rightProvides);
   return (
     left.id === right.id &&
     left.version === right.version &&
-    sameStrings(left.requires ?? [], right.requires ?? []) &&
+    Object.is(left.activate, right.activate) &&
-    leftProvides.length === rightProvides.length &&
+    sameStringsUnordered(left.requires ?? [], right.requires ?? []) &&
-    leftProvides.every(
+    leftCapabilities.length === rightCapabilities.length &&
-      ([capability, service], index) =>
+    leftCapabilities.every(
-        rightProvides[index]?.[0] === capability && Object.is(rightProvides[index]?.[1], service),
+      (capability) =>
+        Object.hasOwn(rightProvides, capability) &&
+        Object.is(leftProvides[capability], rightProvides[capability]),
     )
   );
 }
   );
 }
-function aggregateErrorWithCause(errors: ReadonlyArray<unknown>, message: string, cause: unknown) {
+async function cleanupComposition(
-  return new AggregateError(errors, message, { cause });
-}
-async function disposeComposition(
   composition: Composition,
   onDeactivate?: (pluginId: string) => void,
 ) {
     }
     errors.push(...plugin.cleanupErrors.splice(0));
   }
+  return errors;
+}
+async function disposeComposition(
+  composition: Composition,
+  onDeactivate?: (pluginId: string) => void,
+) {
+  const errors = await cleanupComposition(composition, onDeactivate);
   if (errors.length) {
     throw new AggregateError(errors, "plugin composition cleanup failed");
   }
     return result;
   };
+  const reportCleanupErrors = (phase: "retire" | "rollback", errors: ReadonlyArray<unknown>) => {
+    for (const error of errors) {
+      try {
+        options.onCleanupError?.({ phase, error });
+      } catch {
+        // Cleanup reporting must not replace activation errors or undo a committed snapshot.
+      }
+    }
+  };
   const reconcile = (definitions: ReadonlyArray<PluginDefinition>) =>
     runExclusive(async () => {
       if (disposed) throw new Error("plugin runtime is disposed");
                 finalizers.push(finalizer);
               },
             });
-            options.onLifecycle?.({ phase: "activate", pluginId: definition.id });
           };
           cordisPlugin.inject = [...(definition.requires ?? [])];
           cordisPlugin.provide = Object.keys(definition.provides ?? {});
           try {
             await fiber;
           } catch (error) {
-            try {
+            const cleanupErrors = await cleanupComposition({
-              await disposeComposition({ plugins: [plugin], snapshot: emptySnapshot });
+              plugins: [plugin],
-            } catch (cleanupError) {
+              snapshot: emptySnapshot,
-              throw aggregateErrorWithCause(
+            });
-                [error, cleanupError],
+            reportCleanupErrors("rollback", cleanupErrors);
-                `plugin ${definition.id} activation and cleanup failed`,
-                cleanupError,
-              );
-            }
             throw error;
           }
           staged.set(definition.id, plugin);
         }
       } catch (error) {
-        try {
+        const cleanupErrors = await cleanupComposition({
-          await disposeComposition({ plugins: [...staged.values()], snapshot: emptySnapshot });
+          plugins: [...staged.values()],
-        } catch (cleanupError) {
+          snapshot: emptySnapshot,
-          throw aggregateErrorWithCause(
+        });
-            [error, cleanupError],
+        reportCleanupErrors("rollback", cleanupErrors);
-            "plugin composition activation and rollback failed",
-            cleanupError,
-          );
-        }
         throw error;
       }
       const candidate = { plugins, snapshot: snapshotOf(plugins, blocked) };
       const previous = composition.plugins.filter((plugin) => !plugins.includes(plugin));
       composition = candidate;
-      await disposeComposition({ plugins: previous, snapshot: emptySnapshot }, (pluginId) =>
+      for (const plugin of staged.values()) {
-        options.onLifecycle?.({ phase: "deactivate", pluginId }),
+        options.onLifecycle?.({ phase: "activate", pluginId: plugin.definition.id });
+      }
+      const cleanupErrors = await cleanupComposition(
+        { plugins: previous, snapshot: emptySnapshot },
+        (pluginId) => options.onLifecycle?.({ phase: "deactivate", pluginId }),
       );
+      reportCleanupErrors("retire", cleanupErrors);
       return candidate.snapshot;
     });

packages/plugin-runtime-poc/src/effectScopeRuntime.ts+61−30

   return { blocked: blockedRecord, definitions: ordered };
 };
-const sameStrings = (left: ReadonlyArray<string>, right: ReadonlyArray<string>) =>
+const sameStrings = (left: ReadonlyArray<string>, right: ReadonlyArray<string>) => {
-  left.length === right.length && left.every((value, index) => value === right[index]);
+  if (left.length !== right.length) return false;
+  const sortedLeft = [...left].sort();
+  const sortedRight = [...right].sort();
+  return sortedLeft.every((value, index) => value === sortedRight[index]);
+};
 const sameDefinition = (left: PluginDefinition, right: PluginDefinition): boolean => {
-  if (left.id !== right.id || left.version !== right.version) return false;
+  if (
+    left.id !== right.id ||
+    left.version !== right.version ||
+    !Object.is(left.activate, right.activate)
+  ) {
+    return false;
+  }
   if (!sameStrings(left.requires ?? [], right.requires ?? [])) return false;
-  const leftProvides = Object.entries(left.provides ?? {});
+  const leftProvides = left.provides ?? {};
-  const rightProvides = Object.entries(right.provides ?? {});
+  const rightProvides = right.provides ?? {};
+  const leftCapabilities = Object.keys(leftProvides);
+  const rightCapabilities = Object.keys(rightProvides);
   return (
-    leftProvides.length === rightProvides.length &&
+    leftCapabilities.length === rightCapabilities.length &&
-    leftProvides.every(
+    leftCapabilities.every(
-      ([capability, service], index) =>
+      (capability) =>
-        rightProvides[index]?.[0] === capability && Object.is(rightProvides[index]?.[1], service),
+        Object.hasOwn(rightProvides, capability) &&
+        Object.is(leftProvides[capability], rightProvides[capability]),
     )
   );
 };
   return affected;
 };
-const closePlugins = async (plugins: ReadonlyArray<LivePlugin>): Promise<void> => {
+const closePlugins = async (
+  plugins: ReadonlyArray<LivePlugin>,
+  onDeactivate?: (pluginId: string) => void,
+): Promise<ReadonlyArray<unknown>> => {
   const errors: Array<unknown> = [];
   for (const plugin of plugins.toReversed()) {
     try {
     } catch (error) {
       errors.push(error);
     }
+    try {
+      onDeactivate?.(plugin.definition.id);
+    } catch (error) {
+      errors.push(error);
+    }
   }
-  if (errors.length > 0) {
+  return errors;
-    throw new AggregateError(errors, "Failed to close plugin scopes");
-  }
 };
 const snapshotOf = (
   let disposed = false;
   let transition: Promise<void> = Promise.resolve();
+  const reportCleanupErrors = (phase: "retire" | "rollback", errors: ReadonlyArray<unknown>) => {
+    for (const error of errors) {
+      try {
+        options.onCleanupError?.({ phase, error });
+      } catch {
+        // Cleanup reporting must not replace activation errors or undo a committed snapshot.
+      }
+    }
+  };
   const activatePlugin = async (
     definition: PluginDefinition,
     capabilities: ReadonlyMap<string, unknown>,
   ): Promise<LivePlugin> => {
     const scope = Effect.runSync(Scope.make("sequential"));
     const contributions = new Map<string, Array<Contribution>>();
-    let activated = false;
+    const plugin = { definition, scope, contributions };
-    Effect.runSync(
-      Scope.addFinalizer(
-        scope,
-        Effect.sync(() => {
-          if (activated) options.onLifecycle?.({ phase: "deactivate", pluginId: definition.id });
-        }),
-      ),
-    );
     const context: PluginActivationContext = {
       resolve: <Service>(capability: string): Service => {
           Effect.provideService(Scope.Scope, scope),
         ),
       );
-      activated = true;
+      return plugin;
-      options.onLifecycle?.({ phase: "activate", pluginId: definition.id });
-      return { definition, scope, contributions };
     } catch (error) {
-      await Effect.runPromise(Scope.close(scope, Exit.void));
+      const cleanupErrors = await closePlugins([plugin]);
+      reportCleanupErrors("rollback", cleanupErrors);
       throw error;
     }
   };
             }
           }
         } catch (error) {
-          await closePlugins([...staged.values()]);
+          const cleanupErrors = await closePlugins([...staged.values()]);
+          reportCleanupErrors("rollback", cleanupErrors);
           throw error;
         }
           plugins: nextPlugins,
           snapshot: snapshotOf(nextPlugins, plan.blocked),
         };
-        await closePlugins(previous);
+        for (const plugin of staged.values()) {
+          options.onLifecycle?.({ phase: "activate", pluginId: plugin.definition.id });
+        }
+        const cleanupErrors = await closePlugins(previous, (pluginId) =>
+          options.onLifecycle?.({ phase: "deactivate", pluginId }),
+        );
+        reportCleanupErrors("retire", cleanupErrors);
         return current.snapshot;
       }),
     snapshot: () => current.snapshot,
         disposed = true;
         const previous = current.plugins;
         current = { plugins: [], snapshot: emptySnapshot() };
-        await closePlugins(previous);
+        const cleanupErrors = await closePlugins(previous, (pluginId) =>
+          options.onLifecycle?.({ phase: "deactivate", pluginId }),
+        );
+        if (cleanupErrors.length > 0) {
+          throw new AggregateError(cleanupErrors, "Failed to close plugin scopes");
+        }
       }),
   };
 };

packages/plugin-runtime-poc/src/manifest.test.ts+16−0

@@ -40,9 +40,25 @@ describe("PluginManifest", () => { · 39 unmodified lines
40		40
41	it("rejects malformed versions and capability ids", () => {	41	it("rejects malformed versions and capability ids", () => {
42	expect(() => decodeManifest({ ...validManifest, version: "next" })).toThrow();	42	expect(() => decodeManifest({ ...validManifest, version: "next" })).toThrow();
		43	expect(() => decodeManifest({ ...validManifest, version: "01.2.3" })).toThrow();
		44	expect(() => decodeManifest({ ...validManifest, version: "1.2.3-.." })).toThrow();
		45	expect(decodeManifest({ ...validManifest, version: "1.2.3+build.7" }).version).toBe(
		46	"1.2.3+build.7",
		47	);
43	expect(() => decodeManifest({ ...validManifest, requires: ["t3.commands"] })).toThrow();	48	expect(() => decodeManifest({ ...validManifest, requires: ["t3.commands"] })).toThrow();
44	});	49	});
45		50
		51	it("rejects entrypoints that escape the plugin directory", () => {
		52	for (const server of ["./../outside.js", "./dist/../../outside.js"]) {
		53	expect(() =>
		54	decodeManifest({
		55	...validManifest,
		56	entrypoints: { ...validManifest.entrypoints, server },
		57	}),
		58	).toThrow();
		59	}
		60	});
		61
46	it("keeps mobile declarative by excluding a mobile executable entrypoint", () => {	62	it("keeps mobile declarative by excluding a mobile executable entrypoint", () => {
47	const decoded = decodeManifest({	63	const decoded = decodeManifest({
48	...validManifest,	64	...validManifest,

packages/plugin-runtime-poc/src/manifest.ts+6−2

 );
 const SemanticVersion = Schema.String.check(
-  Schema.isPattern(/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/),
+  Schema.isPattern(
+    /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-(?:0|[1-9]\d*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*))*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/,
+  ),
 );
 const CapabilityId = Schema.String.check(Schema.isPattern(/^[a-z0-9][a-z0-9.-]*@[1-9]\d*$/));
-const RelativeEntrypoint = Schema.String.check(Schema.isPattern(/^\.\/[A-Za-z0-9_./-]+$/));
+const RelativeEntrypoint = Schema.String.check(
+  Schema.isPattern(/^\.\/(?!(?:\.\.(?:\/|$)|.*\/\.\.(?:\/|$)))[A-Za-z0-9_./-]+$/),
+);
 const Permission = Schema.String.check(Schema.isPattern(/^[a-z][a-z-]*:.+$/));
 const ContributionCatalog = Schema.Struct({

packages/plugin-runtime-poc/src/pureRuntime.ts+33−17

 };
 const sameDefinitionShape = (previous: PluginDefinition, desired: PluginDefinition) => {
-  const previousRequires = previous.requires ?? [];
+  const previousRequires = [...(previous.requires ?? [])].sort();
-  const desiredRequires = desired.requires ?? [];
+  const desiredRequires = [...(desired.requires ?? [])].sort();
   const previousProvidedServices = previous.provides ?? {};
   const desiredProvidedServices = desired.provides ?? {};
   const previousProvides = Object.keys(previousProvidedServices);
   return (
     previous.version === desired.version &&
+    Object.is(previous.activate, desired.activate) &&
     previousRequires.length === desiredRequires.length &&
     previousRequires.every((capability, index) => capability === desiredRequires[index]) &&
     previousProvides.length === desiredProvides.length &&
     previousProvides.every(
-      (capability, index) =>
+      (capability) =>
-        capability === desiredProvides[index] &&
+        Object.hasOwn(desiredProvidedServices, capability) &&
         Object.is(previousProvidedServices[capability], desiredProvidedServices[capability]),
     )
   );
 };
-const messageOf = (error: unknown) =>
-  error instanceof Error ? error.message : "plugin activation failed";
 export const createPureRuntime: PluginRuntimeFactory = (options = {}): PluginRuntime => {
   let current = emptyComposition();
   let disposed = false;
     return errors;
   };
+  const reportCleanupErrors = (phase: "retire" | "rollback", errors: ReadonlyArray<unknown>) => {
+    for (const error of errors) {
+      try {
+        options.onCleanupError?.({ phase, error });
+      } catch {
+        // Cleanup reporting must not replace an activation failure or invalidate a commit.
+      }
+    }
+  };
   const stage = async (
     definitions: ReadonlyArray<PluginDefinition>,
     previous: Composition,
           activating = false;
         }
-        instance.activated = true;
-        options.onLifecycle?.({ phase: "activate", pluginId: definition.id });
         for (const [capability, service] of Object.entries(definition.provides ?? {})) {
           services.set(capability, service);
         }
       };
     } catch (activationError) {
       const cleanupErrors = await deactivateAll(staged);
-      if (cleanupErrors.length > 0) {
+      reportCleanupErrors("rollback", cleanupErrors);
-        throw new Error(
-          `${messageOf(activationError)}; ${cleanupErrors.length} rollback finalizer(s) also failed`,
-          { cause: activationError },
-        );
-      }
       throw activationError;
     }
   };
         const candidate = await stage(desired, previous);
         current = candidate;
+        const lifecycleErrors: Array<unknown> = [];
+        for (const instance of candidate.instances) {
+          if (instance.activated) continue;
+          instance.activated = true;
+          try {
+            options.onLifecycle?.({ phase: "activate", pluginId: instance.definition.id });
+          } catch (error) {
+            lifecycleErrors.push(error);
+          }
+        }
         const retained = new Set(candidate.instances);
         const retired = previous.instances.filter((instance) => !retained.has(instance));
         const cleanupErrors = await deactivateAll(retired);
-        if (cleanupErrors.length > 0) {
+        reportCleanupErrors("retire", cleanupErrors);
-          throw new AggregateError(cleanupErrors, "previous composition deactivation failed");
+        if (lifecycleErrors.length > 0) {
+          throw new AggregateError(
+            lifecycleErrors,
+            "committed composition lifecycle reporting failed",
+          );
         }
         return candidate.snapshot;
       });

packages/plugin-runtime-poc/src/runtimeContract.ts+143−2

@@ -116,6 +116,78 @@ export function defineRuntimeContract(name: string, createRuntime: PluginRuntime · 115 unmodified lines
116	expect(disposals).toBe(1);	116	expect(disposals).toBe(1);
117	});	117	});
118		118
		119	it("treats reordered requirements and providers as the same definition", async () => {
		120	let activations = 0;
		121	const firstService = {};
		122	const secondService = {};
		123	const activate: PluginDefinition["activate"] = () => {
		124	activations += 1;
		125	};
		126	const dependencies: ReadonlyArray<PluginDefinition> = [
		127	{
		128	id: "acme.first-dependency",
		129	version: "1.0.0",
		130	provides: { "acme.first@1": true },
		131	activate() {},
		132	},
		133	{
		134	id: "acme.second-dependency",
		135	version: "1.0.0",
		136	provides: { "acme.second@1": true },
		137	activate() {},
		138	},
		139	];
		140	const runtime = createRuntime();
		141	await runtime.reconcile([
		142	...dependencies,
		143	{
		144	id: "acme.stable-order",
		145	version: "1.0.0",
		146	requires: ["acme.first@1", "acme.second@1"],
		147	provides: { "acme.output-one@1": firstService, "acme.output-two@1": secondService },
		148	activate,
		149	},
		150	]);
		151
		152	await runtime.reconcile([
		153	...dependencies,
		154	{
		155	id: "acme.stable-order",
		156	version: "1.0.0",
		157	requires: ["acme.second@1", "acme.first@1"],
		158	provides: { "acme.output-two@1": secondService, "acme.output-one@1": firstService },
		159	activate,
		160	},
		161	]);
		162
		163	expect(activations).toBe(1);
		164	await runtime.dispose();
		165	});
		166
		167	it("restarts a plugin when its activation implementation changes", async () => {
		168	const runtime = createRuntime();
		169	const first: PluginDefinition = {
		170	id: "acme.implementation",
		171	version: "1.0.0",
		172	activate(context) {
		173	context.register("commands", { id: "implementation", label: "first" });
		174	},
		175	};
		176	const second: PluginDefinition = {
		177	id: "acme.implementation",
		178	version: "1.0.0",
		179	activate(context) {
		180	context.register("commands", { id: "implementation", label: "second" });
		181	},
		182	};
		183
		184	await runtime.reconcile([first]);
		185	const snapshot = await runtime.reconcile([second]);
		186
		187	expect(contributionLabels(snapshot, "commands")).toEqual(["second"]);
		188	await runtime.dispose();
		189	});
		190
119	it("restarts a changed provider and its dependents without touching independent plugins", async () => {	191	it("restarts a changed provider and its dependents without touching independent plugins", async () => {
120	let independentActivations = 0;	192	let independentActivations = 0;
121	const lifecycle: Array<string> = [];	193	const lifecycle: Array<string> = [];
@@ -237,11 +309,16 @@ export function defineRuntimeContract(name: string, createRuntime: PluginRuntime · 115 unmodified lines
237	await runtime.dispose();	309	await runtime.dispose();
238	});	310	});
239		311
240	it("does not report a failed candidate as activated", async () => {	312	it("does not report a rolled-back candidate as activated", async () => {
241	const lifecycle: Array<string> = [];	313	const lifecycle: Array<string> = [];
242	const runtime = createRuntime({	314	const runtime = createRuntime({
243	onLifecycle: ({ phase, pluginId }) => lifecycle.push(`${phase}:${pluginId}`),	315	onLifecycle: ({ phase, pluginId }) => lifecycle.push(`${phase}:${pluginId}`),
244	});	316	});
		317	const staged: PluginDefinition = {
		318	id: "acme.staged",
		319	version: "1.0.0",
		320	activate() {},
		321	};
245	const broken: PluginDefinition = {	322	const broken: PluginDefinition = {
246	id: "acme.broken",	323	id: "acme.broken",
247	version: "1.0.0",	324	version: "1.0.0",
@@ -250,12 +327,76 @@ export function defineRuntimeContract(name: string, createRuntime: PluginRuntime · 2 unmodified lines
250	},	327	},
251	};	328	};
252		329
253	await expect(runtime.reconcile([broken])).rejects.toThrow("activation failed");	330	await expect(runtime.reconcile([staged, broken])).rejects.toThrow("activation failed");
254		331
255	expect(lifecycle).toEqual([]);	332	expect(lifecycle).toEqual([]);
256	await runtime.dispose();	333	await runtime.dispose();
257	});	334	});
258		335
		336	it("preserves activation failures when rollback cleanup also fails", async () => {
		337	const activationError = new Error("activation failed");
		338	const cleanupError = new Error("rollback cleanup failed");
		339	const cleanupEvents: Array<{ readonly phase: string; readonly error: unknown }> = [];
		340	const runtime = createRuntime({
		341	onCleanupError: (event) => {
		342	cleanupEvents.push(event);
		343	throw new Error("cleanup observer failed");
		344	},
		345	});
		346	const broken: PluginDefinition = {
		347	id: "acme.rollback-error",
		348	version: "1.0.0",
		349	activate(context) {
		350	context.onDispose(() => {
		351	throw cleanupError;
		352	});
		353	throw activationError;
		354	},
		355	};
		356
		357	await expect(runtime.reconcile([broken])).rejects.toBe(activationError);
		358	expect(cleanupEvents).toEqual([{ phase: "rollback", error: cleanupError }]);
		359	await runtime.dispose();
		360	});
		361
		362	it("returns the committed snapshot when retiring an old plugin reports cleanup errors", async () => {
		363	const cleanupError = new Error("retirement cleanup failed");
		364	const cleanupEvents: Array<{ readonly phase: string; readonly error: unknown }> = [];
		365	const runtime = createRuntime({
		366	onCleanupError: (event) => {
		367	cleanupEvents.push(event);
		368	throw new Error("cleanup observer failed");
		369	},
		370	});
		371	await runtime.reconcile([
		372	{
		373	id: "acme.retirement-error",
		374	version: "1.0.0",
		375	activate(context) {
		376	context.register("commands", { id: "retirement", label: "old" });
		377	context.onDispose(() => {
		378	throw cleanupError;
		379	});
		380	},
		381	},
		382	]);
		383
		384	const snapshot = await runtime.reconcile([
		385	{
		386	id: "acme.retirement-error",
		387	version: "2.0.0",
		388	activate(context) {
		389	context.register("commands", { id: "retirement", label: "new" });
		390	},
		391	},
		392	]);
		393
		394	expect(contributionLabels(snapshot, "commands")).toEqual(["new"]);
		395	expect(runtime.snapshot()).toBe(snapshot);
		396	expect(cleanupEvents).toEqual([{ phase: "retire", error: cleanupError }]);
		397	await runtime.dispose();
		398	});
		399
259	it("attempts every plugin cleanup when one finalizer fails", async () => {	400	it("attempts every plugin cleanup when one finalizer fails", async () => {
260	const disposed: Array<string> = [];	401	const disposed: Array<string> = [];
261	const runtime = createRuntime();	402	const runtime = createRuntime();