@smthrs/plugin 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/Hooks.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Hooks_exports = {};
+__export(Hooks_exports, {
+  engineHooks: () => engineHooks,
+  handlerOf: () => handlerOf,
+  orderOf: () => orderOf
+});
+module.exports = __toCommonJS(Hooks_exports);
+const sharedHooks = /* @__PURE__ */ Object.create(null);
+Object.defineProperties(sharedHooks, {
+  config: { value: "waterfall", enumerable: true },
+  configResolved: { value: "parallel", enumerable: true }
+});
+const engineHooks = Object.freeze(sharedHooks);
+const handlerOf = (entry) => typeof entry === "function" ? entry : entry.handler;
+const orderOf = (entry) => typeof entry === "function" ? void 0 : entry.order;
+//# sourceMappingURL=Hooks.js.map

package/dist/cjs/Hooks.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Hooks.ts"],
+  "sourcesContent": ["/**\n * The typed hook surface: hook kinds, the hook entry shape, and the shared\n * kernel's base hook catalog.\n *\n * The public package contract is documented at\n * {@link https://smithers.sh/docs/reference/api/plugin}. The shared catalog is limited to\n * `config` and `configResolved`;\n * `@smthrs/agent` adds only `cellRegistry`, `cellFlows`, and\n * `cellModelRequest`. Durable-core lifecycle policy is not a hook catalog.\n *\n * `FlowsHooks` is **open for augmentation, closed for dispatch**: a host\n * declares its hooks with `declare module \"@smthrs/plugin\"`, supplies the\n * matching runtime catalog, and dispatches only that bounded set.\n *\n * @since 1.0.0-rc.0\n */\n\nimport type * as Effect from \"effect/Effect\"\n\n/**\n * Dispatch semantics of a hook, fixed by the core.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type HookKind = \"sequential\" | \"parallel\" | \"first\" | \"waterfall\"\n\ndeclare const HookTypeId: unique symbol\n\n/**\n * Phantom carrier that records a hook's kind and handler type in the type\n * system without adding anything at runtime.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface HookMeta<K extends HookKind, F> {\n  readonly [HookTypeId]?: { readonly kind: K; readonly handler: F }\n}\n\n/**\n * The object form of a hook entry: Vite's per-hook ordering object, verbatim.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface HookObject<F> {\n  readonly order?: \"pre\" | \"post\" | undefined\n  readonly handler: F\n}\n\n/**\n * A hook entry is either the bare handler or `{ order?, handler }`.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type HookEntry<K extends HookKind, F> = (F | HookObject<F>) & HookMeta<K, F>\n\n/**\n * Every handler runs, in resolved order, one at a time.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type SequentialHook<F> = HookEntry<\"sequential\", F>\n\n/**\n * Every handler runs concurrently; results are ignored and failures are\n * returned to the caller rather than failing it.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type ParallelHook<F> = HookEntry<\"parallel\", F>\n\n/**\n * Handlers run in order until one returns `Option.some`.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type FirstHook<F> = HookEntry<\"first\", F>\n\n/**\n * Each handler receives the previous handler's output.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type WaterfallHook<F> = HookEntry<\"waterfall\", F>\n\n/**\n * Extracts the declared kind of a hook entry type.\n *\n * @category type-level\n * @since 1.0.0-rc.0\n */\nexport type KindOf<T> = T extends HookMeta<infer K, any> ? K : never\n\n/**\n * The runtime catalog a host supplies for a hook interface: each hook name\n * mapped to its kind. A name declared in `H` must carry the kind its type\n * declares. Names outside `H` are admitted with any kind, because the type\n * system cannot enumerate an augmentable interface; resolution checks them\n * at runtime and dispatch refuses a kind that disagrees with the catalog.\n *\n * @category type-level\n * @since 1.0.0-rc.0\n */\nexport type HookCatalog<H> =\n  & { readonly [K in keyof H & string]?: KindOf<H[K]> }\n  & { readonly [name: string]: HookKind | undefined }\n\n/**\n * Extracts the handler type of a hook entry type.\n *\n * @category type-level\n * @since 1.0.0-rc.0\n */\nexport type HandlerOf<T> = T extends HookMeta<any, infer F> ? F : never\n\n/**\n * Selects the hook names of a given kind from a hook interface.\n *\n * @category type-level\n * @since 1.0.0-rc.0\n */\nexport type KeysOfKind<H, K extends HookKind> =\n  & {\n    [P in keyof H]: KindOf<H[P]> extends K ? P : never\n  }[keyof H]\n  & string\n\n/**\n * Extracts the positional argument tuple accepted by a hook entry.\n *\n * @category type-level\n * @since 1.0.0-rc.0\n */\nexport type ArgsOf<T> = HandlerOf<T> extends (...args: infer A) => any ? A : never\n\n/**\n * Extracts the Effect returned by a hook entry.\n *\n * @category type-level\n * @since 1.0.0-rc.0\n */\nexport type ReturnOf<T> = HandlerOf<T> extends (...args: any) => infer R ? R : never\n\n/**\n * Extracts the success value returned by a hook entry's Effect.\n *\n * @category type-level\n * @since 1.0.0-rc.0\n */\nexport type SuccessOf<T> = ReturnOf<T> extends Effect.Effect<infer A, any, any> ? A : never\n\n/**\n * Extracts the context required by a hook entry's Effect.\n *\n * @category type-level\n * @since 1.0.0-rc.0\n */\nexport type ContextOf<T> = ReturnOf<T> extends Effect.Effect<any, any, infer R> ? R : never\n\n/**\n * Runtime catalog of the shared kernel's hook names and kinds.\n *\n * The type system cannot enumerate an augmentable interface, so this constant\n * is what the `unknown_hook` guard checks against. A host passes its own\n * superset to {@link resolve}. The cell harness adds only the hooks it\n * dispatches; lifecycle and engine-policy hooks do not belong here.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nconst sharedHooks: { config: \"waterfall\"; configResolved: \"parallel\" } = Object.create(null)\nObject.defineProperties(sharedHooks, {\n  config: { value: \"waterfall\", enumerable: true },\n  configResolved: { value: \"parallel\", enumerable: true }\n})\n/**\n * Frozen runtime catalog for the shared configuration hooks.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport const engineHooks: Readonly<{\n  readonly config: \"waterfall\"\n  readonly configResolved: \"parallel\"\n}> = Object.freeze(sharedHooks)\n\n/**\n * Normalizes a hook entry to its handler.\n *\n * @category utils\n * @since 1.0.0-rc.0\n */\nexport const handlerOf = (entry: unknown): (...args: Array<any>) => unknown =>\n  typeof entry === \"function\"\n    ? entry as (...args: Array<any>) => unknown\n    : (entry as HookObject<(...args: Array<any>) => unknown>).handler\n\n/**\n * Reads the per-hook `order` of a hook entry.\n *\n * @category utils\n * @since 1.0.0-rc.0\n */\nexport const orderOf = (entry: unknown): \"pre\" | \"post\" | undefined =>\n  typeof entry === \"function\" ? undefined : (entry as HookObject<unknown>).order\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiLA,MAAM,cAAmE,uBAAO,OAAO,IAAI;AAC3F,OAAO,iBAAiB,aAAa;AAAA,EACnC,QAAQ,EAAE,OAAO,aAAa,YAAY,KAAK;AAAA,EAC/C,gBAAgB,EAAE,OAAO,YAAY,YAAY,KAAK;AACxD,CAAC;AAOM,MAAM,cAGR,OAAO,OAAO,WAAW;AAQvB,MAAM,YAAY,CAAC,UACxB,OAAO,UAAU,aACb,QACC,MAAuD;AAQvD,MAAM,UAAU,CAAC,UACtB,OAAO,UAAU,aAAa,SAAa,MAA8B;",
+  "names": []
+}

package/dist/cjs/Kernel.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Startup: resolve the plugin list, run the config pipeline, hand back a
+ * dispatcher, a frozen config, and the merged layer.
+ *
+ * The public package contract is documented at
+ * {@link https://smithers.sh/docs/reference/api/plugin}, with the shipped host catalog in
+ * `packages/smithers/agent/src/CellPlugin.ts`. D14 in
+ * `docs/pages/design-decisions.md` keeps durable policy outside these hooks.
+ *
+ * Order of operations, per the spec:
+ *
+ * 1. flatten / filter / validate / order the plugin list;
+ * 2. `config` waterfall: each plugin may return a partial to deep-merge;
+ * 3. decode and freeze into a `ResolvedConfig` (`config_invalid` on failure);
+ * 4. `configResolved` parallel: observers capture the final config;
+ * 5. plugin `layer`s merge left-to-right.
+ *
+ * @since 1.0.0-rc.0
+ */
+import * as Effect from "effect/Effect";
+import type * as Layer from "effect/Layer";
+import type { FlowsConfig, ResolvedConfig } from "./Config.ts";
+import type { ContextOf } from "./Hooks.ts";
+import type { FlowsHooks } from "./index.ts";
+import type { PluginInput } from "./Plugin.ts";
+import type { PluginError } from "./PluginError.ts";
+import * as Plugins from "./Plugins.ts";
+import * as Resolve from "./Resolve.ts";
+/**
+ * Everything startup produces from a plugin list and a raw config.
+ *
+ * `observerErrors` carries `configResolved` failures: parallel observers are
+ * lossy by contract, so they are reported rather than fatal.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface Kernel<H = FlowsHooks> {
+    readonly plugins: Plugins.Service<H>;
+    readonly config: ResolvedConfig;
+    readonly layer: Layer.Layer<any, PluginError, any>;
+    readonly observerErrors: ReadonlyArray<PluginError>;
+}
+type HookAt<H, K extends string> = K extends keyof H ? H[K] : never;
+/**
+ * The services a hook interface's `config` hook requires at startup. `never`
+ * for the shared `FlowsHooks`, whose startup hooks are context-free.
+ *
+ * @category type-level
+ * @since 1.0.0-rc.0
+ */
+export type ConfigContext<H> = ContextOf<HookAt<H, "config">>;
+/**
+ * The services a hook interface's startup hooks require: the union of the
+ * `config` and `configResolved` requirements. `Kernel.make` cannot supply
+ * them itself, so they surface in its Effect and the caller provides them.
+ *
+ * @category type-level
+ * @since 1.0.0-rc.0
+ */
+export type StartupContext<H> = ConfigContext<H> | ContextOf<HookAt<H, "configResolved">>;
+/**
+ * Snapshots the config before dispatching the `config` waterfall, then
+ * admits the result as a frozen `ResolvedConfig`.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const runConfig: <H = FlowsHooks>(plugins: Plugins.Service<H>, config: FlowsConfig) => Effect.Effect<ResolvedConfig, PluginError, ConfigContext<H>>;
+/**
+ * Resolves plugins, executes the config pipeline, and merges plugin layers.
+ * The positional `config` is the kernel's only pre-resolution configuration;
+ * the options object cannot declare a second source, and a `config` key
+ * supplied anyway fails with `invalid_plugin` at `$options.config`.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const make: <H = FlowsHooks>(input: PluginInput<NoInfer<H>>, config?: FlowsConfig, options?: Omit<Resolve.Options<NoInfer<H>>, "config">) => Effect.Effect<Kernel<H>, PluginError, StartupContext<H>>;
+export {};
+//# sourceMappingURL=Kernel.d.ts.map

package/dist/cjs/Kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Kernel.d.ts","sourceRoot":"","sources":["../../src/Kernel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAE9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;;;;;;GAQG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC,GAAG,UAAU;IACpC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;IACpC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,CAAC,CAAA;IAClD,QAAQ,CAAC,cAAc,EAAE,aAAa,CAAC,WAAW,CAAC,CAAA;CACpD;AAED,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAA;AAEnE;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAA;AAE7D;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAA;AAEzF;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,GAAG,UAAU,EACtC,SAAS,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAC3B,QAAQ,WAAW,KAClB,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,CAS1D,CAAA;AAEJ;;;;;;;;GAQG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,GAAG,UAAU,EACjC,OAAO,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAC9B,SAAQ,WAAgB,EACxB,UAAS,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAM,KACxD,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC,CAAC,CAgBtD,CAAA"}

package/dist/cjs/Kernel.js

@@ -0,0 +1,57 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Kernel_exports = {};
+__export(Kernel_exports, {
+  make: () => make,
+  runConfig: () => runConfig
+});
+module.exports = __toCommonJS(Kernel_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Config = __toESM(require("./Config.js"), 1);
+var Plugins = __toESM(require("./Plugins.js"), 1);
+var Resolve = __toESM(require("./Resolve.js"), 1);
+const runConfig = (plugins, config) => Effect.gen(function* () {
+  const initial = yield* Config.snapshot(config);
+  const merged = yield* plugins.waterfall("config", initial, Config.merge);
+  return yield* Config.resolve(merged);
+});
+const make = (input, config = {}, options = {}) => Effect.gen(function* () {
+  const initial = yield* Config.snapshot(config);
+  const resolved = yield* Resolve.resolve(input, options, initial);
+  const dispatcher = Plugins.make(resolved);
+  const frozen = yield* runConfig(dispatcher, initial);
+  const observerErrors = yield* dispatcher.parallel("configResolved", frozen);
+  return Object.freeze({
+    plugins: dispatcher,
+    config: frozen,
+    layer: Resolve.layer(resolved),
+    observerErrors
+  });
+});
+//# sourceMappingURL=Kernel.js.map

package/dist/cjs/Kernel.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Kernel.ts"],
+  "sourcesContent": ["/**\n * Startup: resolve the plugin list, run the config pipeline, hand back a\n * dispatcher, a frozen config, and the merged layer.\n *\n * The public package contract is documented at\n * {@link https://smithers.sh/docs/reference/api/plugin}, with the shipped host catalog in\n * `packages/smithers/agent/src/CellPlugin.ts`. D14 in\n * `docs/pages/design-decisions.md` keeps durable policy outside these hooks.\n *\n * Order of operations, per the spec:\n *\n * 1. flatten / filter / validate / order the plugin list;\n * 2. `config` waterfall: each plugin may return a partial to deep-merge;\n * 3. decode and freeze into a `ResolvedConfig` (`config_invalid` on failure);\n * 4. `configResolved` parallel: observers capture the final config;\n * 5. plugin `layer`s merge left-to-right.\n *\n * @since 1.0.0-rc.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport type * as Layer from \"effect/Layer\"\nimport type { FlowsConfig, ResolvedConfig } from \"./Config.ts\"\nimport * as Config from \"./Config.ts\"\nimport type { ContextOf } from \"./Hooks.ts\"\nimport type { FlowsHooks } from \"./index.ts\"\nimport type { PluginInput } from \"./Plugin.ts\"\nimport type { PluginError } from \"./PluginError.ts\"\nimport * as Plugins from \"./Plugins.ts\"\nimport * as Resolve from \"./Resolve.ts\"\n\n/**\n * Everything startup produces from a plugin list and a raw config.\n *\n * `observerErrors` carries `configResolved` failures: parallel observers are\n * lossy by contract, so they are reported rather than fatal.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface Kernel<H = FlowsHooks> {\n  readonly plugins: Plugins.Service<H>\n  readonly config: ResolvedConfig\n  readonly layer: Layer.Layer<any, PluginError, any>\n  readonly observerErrors: ReadonlyArray<PluginError>\n}\n\ntype HookAt<H, K extends string> = K extends keyof H ? H[K] : never\n\n/**\n * The services a hook interface's `config` hook requires at startup. `never`\n * for the shared `FlowsHooks`, whose startup hooks are context-free.\n *\n * @category type-level\n * @since 1.0.0-rc.0\n */\nexport type ConfigContext<H> = ContextOf<HookAt<H, \"config\">>\n\n/**\n * The services a hook interface's startup hooks require: the union of the\n * `config` and `configResolved` requirements. `Kernel.make` cannot supply\n * them itself, so they surface in its Effect and the caller provides them.\n *\n * @category type-level\n * @since 1.0.0-rc.0\n */\nexport type StartupContext<H> = ConfigContext<H> | ContextOf<HookAt<H, \"configResolved\">>\n\n/**\n * Snapshots the config before dispatching the `config` waterfall, then\n * admits the result as a frozen `ResolvedConfig`.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n */\nexport const runConfig = <H = FlowsHooks>(\n  plugins: Plugins.Service<H>,\n  config: FlowsConfig\n): Effect.Effect<ResolvedConfig, PluginError, ConfigContext<H>> =>\n  Effect.gen(function*() {\n    const initial = yield* Config.snapshot(config)\n    const merged = yield* (plugins.waterfall as unknown as (\n      hook: string,\n      initial: FlowsConfig,\n      merge: (previous: FlowsConfig, patch: unknown) => FlowsConfig\n    ) => Effect.Effect<FlowsConfig, PluginError, ConfigContext<H>>)(\"config\", initial, Config.merge)\n    return yield* Config.resolve(merged)\n  })\n\n/**\n * Resolves plugins, executes the config pipeline, and merges plugin layers.\n * The positional `config` is the kernel's only pre-resolution configuration;\n * the options object cannot declare a second source, and a `config` key\n * supplied anyway fails with `invalid_plugin` at `$options.config`.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n */\nexport const make = <H = FlowsHooks>(\n  input: PluginInput<NoInfer<H>>,\n  config: FlowsConfig = {},\n  options: Omit<Resolve.Options<NoInfer<H>>, \"config\"> = {}\n): Effect.Effect<Kernel<H>, PluginError, StartupContext<H>> =>\n  Effect.gen(function*() {\n    const initial = yield* Config.snapshot(config)\n    const resolved = yield* Resolve.resolve<H>(input, options, initial)\n    const dispatcher = Plugins.make<H>(resolved)\n    const frozen = yield* runConfig(dispatcher, initial)\n    const observerErrors = yield* (dispatcher.parallel as unknown as (\n      hook: string,\n      value: ResolvedConfig\n    ) => Effect.Effect<ReadonlyArray<PluginError>, never, StartupContext<H>>)(\"configResolved\", frozen)\n    return Object.freeze({\n      plugins: dispatcher,\n      config: frozen,\n      layer: Resolve.layer(resolved),\n      observerErrors\n    })\n  })\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBA,aAAwB;AAGxB,aAAwB;AAKxB,cAAyB;AACzB,cAAyB;AA8ClB,MAAM,YAAY,CACvB,SACA,WAEA,OAAO,IAAI,aAAY;AACrB,QAAM,UAAU,OAAO,OAAO,SAAS,MAAM;AAC7C,QAAM,SAAS,OAAQ,QAAQ,UAIiC,UAAU,SAAS,OAAO,KAAK;AAC/F,SAAO,OAAO,OAAO,QAAQ,MAAM;AACrC,CAAC;AAWI,MAAM,OAAO,CAClB,OACA,SAAsB,CAAC,GACvB,UAAuD,CAAC,MAExD,OAAO,IAAI,aAAY;AACrB,QAAM,UAAU,OAAO,OAAO,SAAS,MAAM;AAC7C,QAAM,WAAW,OAAO,QAAQ,QAAW,OAAO,SAAS,OAAO;AAClE,QAAM,aAAa,QAAQ,KAAQ,QAAQ;AAC3C,QAAM,SAAS,OAAO,UAAU,YAAY,OAAO;AACnD,QAAM,iBAAiB,OAAQ,WAAW,SAGgC,kBAAkB,MAAM;AAClG,SAAO,OAAO,OAAO;AAAA,IACnB,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,OAAO,QAAQ,MAAM,QAAQ;AAAA,IAC7B;AAAA,EACF,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/cjs/Plugin.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The plugin object: a plain record produced by a factory function.
+ *
+ * The public package contract is documented at
+ * {@link https://smithers.sh/docs/reference/api/plugin}. The shipped consumer is the
+ * assembled cell host in `@smthrs/agent`;
+ * durable-core policy continues to use Effect services and constructor
+ * options rather than plugin lifecycle hooks.
+ *
+ * @since 1.0.0-rc.0
+ */
+import type * as Layer from "effect/Layer";
+import type { FlowsConfig } from "./Config.ts";
+import type { FlowsHooks } from "./index.ts";
+/**
+ * Conditional-inclusion predicate, mirroring Vite's `apply`.
+ *
+ * `"engine"` and `"harness"` select the matching plugin-kernel host. The
+ * assembled cell host resolves as `"harness"`; this does not make `"engine"` an
+ * engine-lifecycle hook registration.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type Apply = "engine" | "harness" | ((config: FlowsConfig) => boolean);
+/**
+ * A flows plugin.
+ *
+ * Generic over the hook interface so a harness can hold plugins typed against
+ * its augmented `FlowsHooks` without any inheritance machinery.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface FlowsPlugin<H = FlowsHooks> {
+    /** Required, unique. Convention: `flows-plugin-<thing>`. */
+    readonly name: string;
+    /**
+     * Semantic identity folded into sealed cache keys. Required when the host
+     * declares a cache environment. `Action.CacheEnvironment` is complete by
+     * contract, so a versionless composition is refused instead of claiming an
+     * ambiguous cross-run identity.
+     */
+    readonly version?: string | undefined;
+    /** Ordering group; omitted means `"normal"`. */
+    readonly enforce?: "pre" | "post" | undefined;
+    /** Conditional inclusion. */
+    readonly apply?: Apply | undefined;
+    /** Services this plugin contributes to the engine environment. */
+    readonly layer?: Layer.Layer<never, any, any> | undefined;
+    /** Typed hooks; only keys declared in the hook interface compile. */
+    readonly hooks?: Partial<H> | undefined;
+}
+/**
+ * What a `plugins` array may contain: plugins, falsy entries, and arrays nested
+ * up to `Resolve.maximumPluginDepth`: so a preset is just a function returning
+ * plugins.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type PluginInput<H = FlowsHooks> = FlowsPlugin<H> | false | null | undefined | ReadonlyArray<PluginInput<H>>;
+/**
+ * Identity constructor that pins a plugin literal to `FlowsPlugin` so excess
+ * hook keys are rejected at the definition site.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const make: <H = FlowsHooks>(plugin: FlowsPlugin<H>) => FlowsPlugin<H>;
+//# sourceMappingURL=Plugin.d.ts.map

package/dist/cjs/Plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Plugin.d.ts","sourceRoot":"","sources":["../../src/Plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;;;;;;;GASG;AACH,MAAM,MAAM,KAAK,GAAG,QAAQ,GAAG,SAAS,GAAG,CAAC,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAA;AAE7E;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,UAAU;IACzC,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACrC,gDAAgD;IAChD,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS,CAAA;IAC7C,6BAA6B;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,SAAS,CAAA;IAClC,kEAAkE;IAClE,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,SAAS,CAAA;IACzD,qEAAqE;IACrE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAA;CACxC;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,UAAU,IAClC,WAAW,CAAC,CAAC,CAAC,GACd,KAAK,GACL,IAAI,GACJ,SAAS,GACT,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAA;AAEjC;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,GAAG,UAAU,EAAE,QAAQ,WAAW,CAAC,CAAC,CAAC,KAAG,WAAW,CAAC,CAAC,CAAW,CAAA"}

package/dist/cjs/Plugin.js

@@ -0,0 +1,25 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Plugin_exports = {};
+__export(Plugin_exports, {
+  make: () => make
+});
+module.exports = __toCommonJS(Plugin_exports);
+const make = (plugin) => plugin;
+//# sourceMappingURL=Plugin.js.map

package/dist/cjs/Plugin.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Plugin.ts"],
+  "sourcesContent": ["/**\n * The plugin object: a plain record produced by a factory function.\n *\n * The public package contract is documented at\n * {@link https://smithers.sh/docs/reference/api/plugin}. The shipped consumer is the\n * assembled cell host in `@smthrs/agent`;\n * durable-core policy continues to use Effect services and constructor\n * options rather than plugin lifecycle hooks.\n *\n * @since 1.0.0-rc.0\n */\n\nimport type * as Layer from \"effect/Layer\"\nimport type { FlowsConfig } from \"./Config.ts\"\nimport type { FlowsHooks } from \"./index.ts\"\n\n/**\n * Conditional-inclusion predicate, mirroring Vite's `apply`.\n *\n * `\"engine\"` and `\"harness\"` select the matching plugin-kernel host. The\n * assembled cell host resolves as `\"harness\"`; this does not make `\"engine\"` an\n * engine-lifecycle hook registration.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type Apply = \"engine\" | \"harness\" | ((config: FlowsConfig) => boolean)\n\n/**\n * A flows plugin.\n *\n * Generic over the hook interface so a harness can hold plugins typed against\n * its augmented `FlowsHooks` without any inheritance machinery.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface FlowsPlugin<H = FlowsHooks> {\n  /** Required, unique. Convention: `flows-plugin-<thing>`. */\n  readonly name: string\n  /**\n   * Semantic identity folded into sealed cache keys. Required when the host\n   * declares a cache environment. `Action.CacheEnvironment` is complete by\n   * contract, so a versionless composition is refused instead of claiming an\n   * ambiguous cross-run identity.\n   */\n  readonly version?: string | undefined\n  /** Ordering group; omitted means `\"normal\"`. */\n  readonly enforce?: \"pre\" | \"post\" | undefined\n  /** Conditional inclusion. */\n  readonly apply?: Apply | undefined\n  /** Services this plugin contributes to the engine environment. */\n  readonly layer?: Layer.Layer<never, any, any> | undefined\n  /** Typed hooks; only keys declared in the hook interface compile. */\n  readonly hooks?: Partial<H> | undefined\n}\n\n/**\n * What a `plugins` array may contain: plugins, falsy entries, and arrays nested\n * up to `Resolve.maximumPluginDepth`: so a preset is just a function returning\n * plugins.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type PluginInput<H = FlowsHooks> =\n  | FlowsPlugin<H>\n  | false\n  | null\n  | undefined\n  | ReadonlyArray<PluginInput<H>>\n\n/**\n * Identity constructor that pins a plugin literal to `FlowsPlugin` so excess\n * hook keys are rejected at the definition site.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n */\nexport const make = <H = FlowsHooks>(plugin: FlowsPlugin<H>): FlowsPlugin<H> => plugin\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA+EO,MAAM,OAAO,CAAiB,WAA2C;",
+  "names": []
+}

package/dist/cjs/PluginError.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The single typed failure of the plugin kernel.
+ *
+ * The public package contract is documented at
+ * {@link https://smithers.sh/docs/reference/api/plugin}; D14 in
+ * `docs/pages/design-decisions.md` bounds it to host-owned cell hooks.
+ *
+ * @since 1.0.0-rc.0
+ */
+import * as Schema from "effect/Schema";
+/**
+ * Closed set of plugin-system failure codes.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export declare const PluginErrorCode: Schema.Literals<readonly ["duplicate_name", "unknown_hook", "hook_kind_mismatch", "invalid_plugin", "apply_failed", "config_invalid", "cache_environment_invalid", "invalid_hook_result", "resource_limit", "hook_failed", "layer_failed"]>;
+/**
+ * Closed set of plugin-system failure codes.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type PluginErrorCode = typeof PluginErrorCode.Type;
+declare const PluginError_base: Schema.Class<PluginError, Schema.TaggedStruct<"flows/plugin/PluginError", {
+    readonly code: Schema.Literals<readonly ["duplicate_name", "unknown_hook", "hook_kind_mismatch", "invalid_plugin", "apply_failed", "config_invalid", "cache_environment_invalid", "invalid_hook_result", "resource_limit", "hook_failed", "layer_failed"]>;
+    readonly message: Schema.String;
+    readonly plugin: Schema.optional<Schema.String>;
+    readonly hook: Schema.optional<Schema.String>;
+    readonly path: Schema.optional<Schema.String>;
+    readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Failure raised by plugin resolution, hook dispatch, config execution, or
+ * layer construction.
+ *
+ * Parallel observer failures never fail the caller; they are returned from
+ * `Plugins.parallel` with this same shape so they can be journalled on the
+ * lossy telemetry channel.
+ *
+ * `cause` is the plugin's unredacted failure and may hold secrets; hosts
+ * redact it before logging, persisting, or transmitting the error.
+ *
+ * @category errors
+ * @since 1.0.0-rc.0
+ */
+export declare class PluginError extends PluginError_base {
+}
+export {};
+//# sourceMappingURL=PluginError.d.ts.map

package/dist/cjs/PluginError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginError.d.ts","sourceRoot":"","sources":["../../src/PluginError.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,eAAe,6OAY1B,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC,IAAI,CAAA;;;;;;;;;AAEzD;;;;;;;;;;;;;GAaG;AACH,qBAAa,WAAY,SAAQ,gBAO/B;CAAG"}

package/dist/cjs/PluginError.js

@@ -0,0 +1,58 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var PluginError_exports = {};
+__export(PluginError_exports, {
+  PluginError: () => PluginError,
+  PluginErrorCode: () => PluginErrorCode
+});
+module.exports = __toCommonJS(PluginError_exports);
+var Schema = __toESM(require("effect/Schema"), 1);
+const PluginErrorCode = Schema.Literals([
+  "duplicate_name",
+  "unknown_hook",
+  "hook_kind_mismatch",
+  "invalid_plugin",
+  "apply_failed",
+  "config_invalid",
+  "cache_environment_invalid",
+  "invalid_hook_result",
+  "resource_limit",
+  "hook_failed",
+  "layer_failed"
+]);
+class PluginError extends Schema.TaggedError()("flows/plugin/PluginError", {
+  code: PluginErrorCode,
+  message: Schema.String,
+  plugin: Schema.optional(Schema.String),
+  hook: Schema.optional(Schema.String),
+  path: Schema.optional(Schema.String),
+  cause: Schema.optional(Schema.Unknown)
+}) {
+}
+//# sourceMappingURL=PluginError.js.map

package/dist/cjs/PluginError.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/PluginError.ts"],
+  "sourcesContent": ["/**\n * The single typed failure of the plugin kernel.\n *\n * The public package contract is documented at\n * {@link https://smithers.sh/docs/reference/api/plugin}; D14 in\n * `docs/pages/design-decisions.md` bounds it to host-owned cell hooks.\n *\n * @since 1.0.0-rc.0\n */\n\nimport * as Schema from \"effect/Schema\"\n\n/**\n * Closed set of plugin-system failure codes.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport const PluginErrorCode = Schema.Literals([\n  \"duplicate_name\",\n  \"unknown_hook\",\n  \"hook_kind_mismatch\",\n  \"invalid_plugin\",\n  \"apply_failed\",\n  \"config_invalid\",\n  \"cache_environment_invalid\",\n  \"invalid_hook_result\",\n  \"resource_limit\",\n  \"hook_failed\",\n  \"layer_failed\"\n])\n\n/**\n * Closed set of plugin-system failure codes.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type PluginErrorCode = typeof PluginErrorCode.Type\n\n/**\n * Failure raised by plugin resolution, hook dispatch, config execution, or\n * layer construction.\n *\n * Parallel observer failures never fail the caller; they are returned from\n * `Plugins.parallel` with this same shape so they can be journalled on the\n * lossy telemetry channel.\n *\n * `cause` is the plugin's unredacted failure and may hold secrets; hosts\n * redact it before logging, persisting, or transmitting the error.\n *\n * @category errors\n * @since 1.0.0-rc.0\n */\nexport class PluginError extends Schema.TaggedError<PluginError>()(\"flows/plugin/PluginError\", {\n  code: PluginErrorCode,\n  message: Schema.String,\n  plugin: Schema.optional(Schema.String),\n  hook: Schema.optional(Schema.String),\n  path: Schema.optional(Schema.String),\n  cause: Schema.optional(Schema.Unknown)\n}) {}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,aAAwB;AAQjB,MAAM,kBAAkB,OAAO,SAAS;AAAA,EAC7C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAwBM,MAAM,oBAAoB,OAAO,YAAyB,EAAE,4BAA4B;AAAA,EAC7F,MAAM;AAAA,EACN,SAAS,OAAO;AAAA,EAChB,QAAQ,OAAO,SAAS,OAAO,MAAM;AAAA,EACrC,MAAM,OAAO,SAAS,OAAO,MAAM;AAAA,EACnC,MAAM,OAAO,SAAS,OAAO,MAAM;AAAA,EACnC,OAAO,OAAO,SAAS,OAAO,OAAO;AACvC,CAAC,EAAE;AAAC;",
+  "names": []
+}

package/dist/cjs/Plugins.d.ts

@@ -0,0 +1,97 @@
+/**
+ * The dispatcher: a plain service over a resolved plugin list, generic over the
+ * hook interface.
+ *
+ * The public package contract is documented at
+ * {@link https://smithers.sh/docs/reference/api/plugin}. Each host holds an instance over its
+ * augmented `FlowsHooks` and may dispatch only the runtime catalog it supplied.
+ * The shipped cell host owns the three
+ * waterfalls declared in `packages/smithers/agent/src/CellPlugin.ts`; there is
+ * no engine-wide lifecycle dispatcher.
+ *
+ * Cancellation is fiber interruption via scope closure; nothing here threads an
+ * `AbortSignal`.
+ *
+ * @since 1.0.0-rc.0
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { ArgsOf, ContextOf, KeysOfKind, SuccessOf } from "./Hooks.ts";
+import type { FlowsHooks } from "./index.ts";
+import { PluginError } from "./PluginError.ts";
+import { type HandlerRecord, type Resolved } from "./Resolve.ts";
+/**
+ * The dispatch surface.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface Service<H = FlowsHooks> {
+    /** The resolved list this dispatcher walks. */
+    readonly resolved: Resolved<H>;
+    /** Frozen, ordered handler records for a hook. */
+    readonly handlers: (hook: string) => ReadonlyArray<HandlerRecord>;
+    /** Runs every handler in resolved order, one at a time. */
+    readonly sequential: <K extends KeysOfKind<H, "sequential">>(hook: K, ...args: ArgsOf<H[K]>) => Effect.Effect<ReadonlyArray<SuccessOf<H[K]>>, PluginError, ContextOf<H[K]>>;
+    /**
+     * Runs every handler concurrently, ignoring results. Never fails: handler
+     * failures are returned so the caller can report them at its own boundary.
+     */
+    readonly parallel: <K extends KeysOfKind<H, "parallel">>(hook: K, ...args: ArgsOf<H[K]>) => Effect.Effect<ReadonlyArray<PluginError>, never, ContextOf<H[K]>>;
+    /** Runs handlers in order until one returns `Option.some`. */
+    readonly first: <K extends KeysOfKind<H, "first">>(hook: K, ...args: ArgsOf<H[K]>) => Effect.Effect<SuccessOf<H[K]>, PluginError, ContextOf<H[K]>>;
+    /** Threads a value through every handler, merging each returned patch. */
+    readonly waterfall: <K extends KeysOfKind<H, "waterfall">>(hook: K, initial: ArgsOf<H[K]>[0], merge: (previous: ArgsOf<H[K]>[0], patch: Exclude<SuccessOf<H[K]>, void>) => ArgsOf<H[K]>[0]) => Effect.Effect<ArgsOf<H[K]>[0], PluginError, ContextOf<H[K]>>;
+}
+/**
+ * Builds a dispatcher over an already resolved plugin list.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const make: <H = FlowsHooks>(resolved: Resolved<H>) => Service<H>;
+/**
+ * A dispatcher with no plugins at all.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const makeNoop: <H = FlowsHooks>() => Service<H>;
+declare const Plugins_base: Context.ServiceClass<Plugins, "flows/plugin/Plugins", Service<FlowsHooks>>;
+/**
+ * The shared dispatcher, as a service tag.
+ *
+ * This tag holds one dispatcher over the process-wide augmented `FlowsHooks`.
+ * `declare module "@smthrs/plugin"` augmentation is the supported extension
+ * mechanism for values placed in the tag. A host typed against a separate hook
+ * interface holds its `Service<H>` directly, as `@smthrs/agent` does, and does
+ * not use this tag or its layers.
+ *
+ * @category context
+ * @since 1.0.0-rc.0
+ */
+export declare class Plugins extends Plugins_base {
+}
+/**
+ * Layer providing a dispatcher over an already resolved plugin list.
+ *
+ * This layer targets the shared augmented `FlowsHooks` catalog only. A host
+ * with a separate hook interface holds its `Service<H>` directly.
+ *
+ * @category layers
+ * @since 1.0.0-rc.0
+ */
+export declare const layer: (resolved: Resolved) => Layer.Layer<Plugins>;
+/**
+ * Layer providing a dispatcher with no plugins.
+ *
+ * This layer targets the shared augmented `FlowsHooks` catalog only. A host
+ * with a separate hook interface holds its `Service<H>` directly.
+ *
+ * @category layers
+ * @since 1.0.0-rc.0
+ */
+export declare const layerNoop: Layer.Layer<Plugins>;
+export {};
+//# sourceMappingURL=Plugins.d.ts.map

package/dist/cjs/Plugins.d.ts.map

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