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

package/dist/cjs/Plugins.js

@@ -0,0 +1,160 @@
+"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 Plugins_exports = {};
+__export(Plugins_exports, {
+  Plugins: () => Plugins,
+  layer: () => layer,
+  layerNoop: () => layerNoop,
+  make: () => make,
+  makeNoop: () => makeNoop
+});
+module.exports = __toCommonJS(Plugins_exports);
+var ImmutableMap = __toESM(require("@smthrs/canonical/ReadonlyMap"), 1);
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var import_Hooks = require("./Hooks.js");
+var import_PluginError = require("./PluginError.js");
+var import_Resolve = require("./Resolve.js");
+const empty = Object.freeze([]);
+const kindMismatch = (resolved, hook, kind) => {
+  if (!Object.hasOwn(resolved.kinds, hook)) return void 0;
+  const declared = resolved.kinds[hook];
+  if (declared === kind) return void 0;
+  return new import_PluginError.PluginError({
+    code: "hook_kind_mismatch",
+    message: `hook "${hook}" is declared ${JSON.stringify(declared)} in the runtime catalog but was dispatched as ${JSON.stringify(kind)}`,
+    hook
+  });
+};
+const runHandler = (record, args) => {
+  const onCause = (cause) => Effect.fail(
+    new import_PluginError.PluginError({
+      code: "hook_failed",
+      message: `hook "${record.hook}" failed in plugin "${record.plugin}"`,
+      plugin: record.plugin,
+      hook: record.hook,
+      cause
+    })
+  );
+  return Effect.sync(() => record.handler(...args)).pipe(
+    Effect.catchCause(onCause),
+    Effect.flatMap(
+      (result) => Effect.isEffect(result) ? result.pipe(Effect.catchCause(onCause)) : Effect.fail(
+        new import_PluginError.PluginError({
+          code: "hook_failed",
+          message: `hook "${record.hook}" in plugin "${record.plugin}" returned a non-Effect (${typeof result})`,
+          plugin: record.plugin,
+          hook: record.hook
+        })
+      )
+    )
+  );
+};
+const make = (resolved) => {
+  const handlers = (hook) => resolved.handlers.get(hook) ?? empty;
+  const sequential = ((hook, ...args) => Effect.gen(function* () {
+    const mismatch = kindMismatch(resolved, hook, "sequential");
+    if (mismatch !== void 0) return yield* Effect.fail(mismatch);
+    const results = [];
+    for (const record of handlers(hook)) {
+      results.push(yield* runHandler(record, args));
+    }
+    return results;
+  }));
+  const parallel = ((hook, ...args) => {
+    const mismatch = kindMismatch(resolved, hook, "parallel");
+    if (mismatch !== void 0) return Effect.succeed([mismatch]);
+    return Effect.forEach(
+      handlers(hook),
+      (record) => runHandler(record, args).pipe(
+        Effect.match({ onFailure: (error) => [error], onSuccess: () => [] })
+      ),
+      { concurrency: resolved.parallelConcurrency }
+    ).pipe(Effect.map((chunks) => chunks.flat()));
+  });
+  const first = ((hook, ...args) => Effect.gen(function* () {
+    const mismatch = kindMismatch(resolved, hook, "first");
+    if (mismatch !== void 0) return yield* Effect.fail(mismatch);
+    for (const record of handlers(hook)) {
+      const result = yield* runHandler(record, args);
+      if (!Option.isOption(result)) {
+        return yield* Effect.fail(
+          new import_PluginError.PluginError({
+            code: "invalid_hook_result",
+            message: `first hook "${record.hook}" in plugin "${record.plugin}" did not return an Option`,
+            plugin: record.plugin,
+            hook: record.hook
+          })
+        );
+      }
+      if (Option.isSome(result)) return result;
+    }
+    return Option.none();
+  }));
+  const waterfall = ((hook, initial, merge) => Effect.gen(function* () {
+    const mismatch = kindMismatch(resolved, hook, "waterfall");
+    if (mismatch !== void 0) return yield* Effect.fail(mismatch);
+    let value = initial;
+    for (const record of handlers(hook)) {
+      const patch = yield* runHandler(record, [value]);
+      if (patch !== void 0) {
+        value = yield* Effect.try({
+          try: () => merge(value, patch),
+          catch: (cause) => cause instanceof import_PluginError.PluginError ? new import_PluginError.PluginError({
+            code: cause.code,
+            message: cause.message,
+            plugin: record.plugin,
+            hook: record.hook,
+            path: cause.path
+          }) : new import_PluginError.PluginError({
+            code: "config_invalid",
+            message: `waterfall hook "${record.hook}" in plugin "${record.plugin}" returned an invalid patch`,
+            plugin: record.plugin,
+            hook: record.hook
+          })
+        });
+      }
+    }
+    return value;
+  }));
+  return Object.freeze({ resolved, handlers, sequential, parallel, first, waterfall });
+};
+const makeNoop = () => make(Object.freeze({
+  plugins: Object.freeze([]),
+  handlers: ImmutableMap.make(),
+  kinds: import_Hooks.engineHooks,
+  parallelConcurrency: import_Resolve.defaultParallelConcurrency
+}));
+class Plugins extends Context.Service()("flows/plugin/Plugins") {
+}
+const layer = (resolved) => Layer.succeed(Plugins)(make(resolved));
+const layerNoop = Layer.succeed(Plugins)(makeNoop());
+//# sourceMappingURL=Plugins.js.map

package/dist/cjs/Plugins.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Plugins.ts"],
+  "sourcesContent": ["/**\n * The dispatcher: a plain service over a resolved plugin list, generic over the\n * hook interface.\n *\n * The public package contract is documented at\n * {@link https://smithers.sh/docs/reference/api/plugin}. Each host holds an instance over its\n * augmented `FlowsHooks` and may dispatch only the runtime catalog it supplied.\n * The shipped cell host owns the three\n * waterfalls declared in `packages/smithers/agent/src/CellPlugin.ts`; there is\n * no engine-wide lifecycle dispatcher.\n *\n * Cancellation is fiber interruption via scope closure; nothing here threads an\n * `AbortSignal`.\n *\n * @since 1.0.0-rc.0\n */\n\nimport * as ImmutableMap from \"@smthrs/canonical/ReadonlyMap\"\nimport type * as Cause from \"effect/Cause\"\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport * as Option from \"effect/Option\"\nimport type { ArgsOf, ContextOf, HookKind, KeysOfKind, SuccessOf } from \"./Hooks.ts\"\nimport { engineHooks } from \"./Hooks.ts\"\nimport type { FlowsHooks } from \"./index.ts\"\nimport { PluginError } from \"./PluginError.ts\"\nimport { defaultParallelConcurrency, type HandlerRecord, type Resolved } from \"./Resolve.ts\"\n\nconst empty: ReadonlyArray<HandlerRecord> = Object.freeze([])\n\n// The typed catalog and the runtime catalog can only drift when a host casts\n// around `KeysOfKind`; refuse before any handler runs rather than execute a\n// hook under semantics its declaration never promised.\nconst kindMismatch = (resolved: Resolved<unknown>, hook: string, kind: HookKind): PluginError | undefined => {\n  if (!Object.hasOwn(resolved.kinds, hook)) return undefined\n  const declared = resolved.kinds[hook]\n  if (declared === kind) return undefined\n  return new PluginError({\n    code: \"hook_kind_mismatch\",\n    message: `hook \"${hook}\" is declared ${JSON.stringify(declared)} in the runtime catalog but was dispatched as ${\n      JSON.stringify(kind)\n    }`,\n    hook\n  })\n}\n\nconst runHandler = (\n  record: HandlerRecord,\n  args: ReadonlyArray<unknown>\n): Effect.Effect<unknown, PluginError, any> => {\n  const onCause = (cause: Cause.Cause<unknown>) =>\n    Effect.fail(\n      new PluginError({\n        code: \"hook_failed\",\n        message: `hook \"${record.hook}\" failed in plugin \"${record.plugin}\"`,\n        plugin: record.plugin,\n        hook: record.hook,\n        cause\n      })\n    )\n\n  return Effect.sync(() => record.handler(...args)).pipe(\n    Effect.catchCause(onCause),\n    Effect.flatMap((result) =>\n      Effect.isEffect(result)\n        ? result.pipe(Effect.catchCause(onCause))\n        : Effect.fail(\n          new PluginError({\n            code: \"hook_failed\",\n            message: `hook \"${record.hook}\" in plugin \"${record.plugin}\" returned a non-Effect (${typeof result})`,\n            plugin: record.plugin,\n            hook: record.hook\n          })\n        )\n    )\n  )\n}\n\n/**\n * The dispatch surface.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface Service<H = FlowsHooks> {\n  /** The resolved list this dispatcher walks. */\n  readonly resolved: Resolved<H>\n  /** Frozen, ordered handler records for a hook. */\n  readonly handlers: (hook: string) => ReadonlyArray<HandlerRecord>\n  /** Runs every handler in resolved order, one at a time. */\n  readonly sequential: <K extends KeysOfKind<H, \"sequential\">>(\n    hook: K,\n    ...args: ArgsOf<H[K]>\n  ) => Effect.Effect<ReadonlyArray<SuccessOf<H[K]>>, PluginError, ContextOf<H[K]>>\n  /**\n   * Runs every handler concurrently, ignoring results. Never fails: handler\n   * failures are returned so the caller can report them at its own boundary.\n   */\n  readonly parallel: <K extends KeysOfKind<H, \"parallel\">>(\n    hook: K,\n    ...args: ArgsOf<H[K]>\n  ) => Effect.Effect<ReadonlyArray<PluginError>, never, ContextOf<H[K]>>\n  /** Runs handlers in order until one returns `Option.some`. */\n  readonly first: <K extends KeysOfKind<H, \"first\">>(\n    hook: K,\n    ...args: ArgsOf<H[K]>\n  ) => Effect.Effect<SuccessOf<H[K]>, PluginError, ContextOf<H[K]>>\n  /** Threads a value through every handler, merging each returned patch. */\n  readonly waterfall: <K extends KeysOfKind<H, \"waterfall\">>(\n    hook: K,\n    initial: ArgsOf<H[K]>[0],\n    merge: (previous: ArgsOf<H[K]>[0], patch: Exclude<SuccessOf<H[K]>, void>) => ArgsOf<H[K]>[0]\n  ) => Effect.Effect<ArgsOf<H[K]>[0], PluginError, ContextOf<H[K]>>\n}\n\n/**\n * Builds a dispatcher over an already resolved plugin list.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n */\nexport const make = <H = FlowsHooks>(resolved: Resolved<H>): Service<H> => {\n  const handlers = (hook: string): ReadonlyArray<HandlerRecord> => resolved.handlers.get(hook) ?? empty\n\n  const sequential = ((hook: string, ...args: Array<unknown>) =>\n    Effect.gen(function*() {\n      const mismatch = kindMismatch(resolved, hook, \"sequential\")\n      if (mismatch !== undefined) return yield* Effect.fail(mismatch)\n      const results: Array<unknown> = []\n      for (const record of handlers(hook)) {\n        results.push(yield* runHandler(record, args))\n      }\n      return results\n    })) as Service<H>[\"sequential\"]\n\n  const parallel = ((hook: string, ...args: Array<unknown>) => {\n    const mismatch = kindMismatch(resolved, hook, \"parallel\")\n    if (mismatch !== undefined) return Effect.succeed([mismatch])\n    return Effect.forEach(\n      handlers(hook),\n      (record) =>\n        runHandler(record, args).pipe(\n          Effect.match({ onFailure: (error) => [error], onSuccess: () => [] as Array<PluginError> })\n        ),\n      { concurrency: resolved.parallelConcurrency }\n    ).pipe(Effect.map((chunks) => chunks.flat()))\n  }) as Service<H>[\"parallel\"]\n\n  const first = ((hook: string, ...args: Array<unknown>) =>\n    Effect.gen(function*() {\n      const mismatch = kindMismatch(resolved, hook, \"first\")\n      if (mismatch !== undefined) return yield* Effect.fail(mismatch)\n      for (const record of handlers(hook)) {\n        const result = yield* runHandler(record, args)\n        if (!Option.isOption(result)) {\n          return yield* Effect.fail(\n            new PluginError({\n              code: \"invalid_hook_result\",\n              message: `first hook \"${record.hook}\" in plugin \"${record.plugin}\" did not return an Option`,\n              plugin: record.plugin,\n              hook: record.hook\n            })\n          )\n        }\n        if (Option.isSome(result)) return result\n      }\n      return Option.none()\n    })) as unknown as Service<H>[\"first\"]\n\n  const waterfall =\n    ((hook: string, initial: unknown, merge: (previous: unknown, patch: unknown) => unknown) =>\n      Effect.gen(function*() {\n        const mismatch = kindMismatch(resolved, hook, \"waterfall\")\n        if (mismatch !== undefined) return yield* Effect.fail(mismatch)\n        let value = initial\n        for (const record of handlers(hook)) {\n          const patch = yield* runHandler(record, [value])\n          if (patch !== undefined) {\n            value = yield* Effect.try({\n              try: () => merge(value, patch),\n              catch: (cause) =>\n                cause instanceof PluginError\n                  ? new PluginError({\n                    code: cause.code,\n                    message: cause.message,\n                    plugin: record.plugin,\n                    hook: record.hook,\n                    path: cause.path\n                  })\n                  : new PluginError({\n                    code: \"config_invalid\",\n                    message: `waterfall hook \"${record.hook}\" in plugin \"${record.plugin}\" returned an invalid patch`,\n                    plugin: record.plugin,\n                    hook: record.hook\n                  })\n            })\n          }\n        }\n        return value\n      })) as Service<H>[\"waterfall\"]\n\n  return Object.freeze({ resolved, handlers, sequential, parallel, first, waterfall })\n}\n\n/**\n * A dispatcher with no plugins at all.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n */\nexport const makeNoop = <H = FlowsHooks>(): Service<H> =>\n  make<H>(Object.freeze({\n    plugins: Object.freeze([]),\n    handlers: ImmutableMap.make<string, ReadonlyArray<HandlerRecord>>(),\n    kinds: engineHooks,\n    parallelConcurrency: defaultParallelConcurrency\n  }))\n\n/**\n * The shared dispatcher, as a service tag.\n *\n * This tag holds one dispatcher over the process-wide augmented `FlowsHooks`.\n * `declare module \"@smthrs/plugin\"` augmentation is the supported extension\n * mechanism for values placed in the tag. A host typed against a separate hook\n * interface holds its `Service<H>` directly, as `@smthrs/agent` does, and does\n * not use this tag or its layers.\n *\n * @category context\n * @since 1.0.0-rc.0\n */\nexport class Plugins extends Context.Service<Plugins, Service>()(\"flows/plugin/Plugins\") {}\n\n/**\n * Layer providing a dispatcher over an already resolved plugin list.\n *\n * This layer targets the shared augmented `FlowsHooks` catalog only. A host\n * with a separate hook interface holds its `Service<H>` directly.\n *\n * @category layers\n * @since 1.0.0-rc.0\n */\nexport const layer = (resolved: Resolved): Layer.Layer<Plugins> => Layer.succeed(Plugins)(make(resolved))\n\n/**\n * Layer providing a dispatcher with no plugins.\n *\n * This layer targets the shared augmented `FlowsHooks` catalog only. A host\n * with a separate hook interface holds its `Service<H>` directly.\n *\n * @category layers\n * @since 1.0.0-rc.0\n */\nexport const layerNoop: Layer.Layer<Plugins> = Layer.succeed(Plugins)(makeNoop())\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/Resolve.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Bounded plugin resolution: admit, filter, validate, order, and snapshot.
+ *
+ * The resulting catalog owns every record it exposes. Dispatch never reads a
+ * caller-owned map, plugin record, hook object, config value, or cache identity.
+ *
+ * @since 1.0.0-rc.0
+ */
+import type { Action } from "@smthrs/flow";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { FlowsConfig } from "./Config.ts";
+import type { HookCatalog, HookKind } from "./Hooks.ts";
+import type { FlowsHooks } from "./index.ts";
+import type { FlowsPlugin, PluginInput } from "./Plugin.ts";
+import { PluginError } from "./PluginError.ts";
+/**
+ * Maximum nested preset-array depth accepted at startup.
+ *
+ * @category limits
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumPluginDepth = 64;
+/**
+ * Maximum plugins accepted by one kernel.
+ *
+ * @category limits
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumPlugins = 256;
+/**
+ * Maximum aggregate hook handlers accepted by one kernel.
+ *
+ * @category limits
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumHandlers = 1024;
+/**
+ * Maximum input nodes, including arrays and omitted entries.
+ *
+ * @category limits
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumPluginInputNodes = 4096;
+/**
+ * Maximum UTF-16 length of one plugin or hook name.
+ *
+ * @category limits
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumPluginNameLength = 256;
+/**
+ * Default fiber bound for parallel observers.
+ *
+ * @category limits
+ * @since 1.0.0-rc.0
+ */
+export declare const defaultParallelConcurrency = 16;
+/**
+ * Maximum configurable parallel-observer bound.
+ *
+ * @category limits
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumParallelConcurrency = 256;
+/**
+ * One resolved handler with immutable attribution.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface HandlerRecord {
+    readonly plugin: string;
+    readonly hook: string;
+    readonly handler: (...args: Array<any>) => unknown;
+}
+/**
+ * The immutable output of plugin resolution.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface Resolved<H = FlowsHooks> {
+    readonly plugins: ReadonlyArray<FlowsPlugin<H>>;
+    readonly handlers: ReadonlyMap<string, ReadonlyArray<HandlerRecord>>;
+    /** The frozen runtime catalog this resolution admitted. Dispatch refuses a method whose kind differs from it. */
+    readonly kinds: Readonly<Record<string, HookKind>>;
+    readonly parallelConcurrency: number;
+    readonly cacheEnvironment?: Action.CacheEnvironment | undefined;
+}
+/**
+ * Options for {@link resolve}.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface Options<H = FlowsHooks> {
+    /** Pre-resolution config tested by `apply` predicates. */
+    readonly config?: FlowsConfig | undefined;
+    /** Host whose literal `apply` selectors are active. Defaults to `"engine"`. */
+    readonly target?: "engine" | "harness" | undefined;
+    /**
+     * Hook names recognized by this host, each with the kind `H` declares for
+     * it. The shared `config` and `configResolved` hooks are fixed to
+     * `waterfall` and `parallel`; another kind fails with `hook_kind_mismatch`.
+     */
+    readonly hooks?: HookCatalog<H> | undefined;
+    /** Complete composition identity for sealed activity keys. Requires every selected plugin to have a version. */
+    readonly cacheEnvironment?: Action.CacheEnvironment | undefined;
+    /** Maximum observers run at once. Defaults to 16 and cannot exceed 256. */
+    readonly parallelConcurrency?: number | undefined;
+}
+/**
+ * Resolves a plugin preset into an immutable, resource-bounded catalog.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const resolve: <H = FlowsHooks>(input: PluginInput<NoInfer<H>>, options?: Options<NoInfer<H>>, configOverride?: FlowsConfig) => Effect.Effect<Resolved<H>, PluginError>;
+/**
+ * Merges every resolved plugin layer left-to-right and supplies the detached
+ * cache environment captured during resolution.
+ *
+ * @category combinators
+ * @since 1.0.0-rc.0
+ */
+export declare const layer: <H>(resolved: Resolved<H>) => Layer.Layer<any, PluginError, any>;
+//# sourceMappingURL=Resolve.d.ts.map

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

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

package/dist/cjs/Resolve.js

@@ -0,0 +1,343 @@
+"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 Resolve_exports = {};
+__export(Resolve_exports, {
+  defaultParallelConcurrency: () => defaultParallelConcurrency,
+  layer: () => layer,
+  maximumHandlers: () => maximumHandlers,
+  maximumParallelConcurrency: () => maximumParallelConcurrency,
+  maximumPluginDepth: () => maximumPluginDepth,
+  maximumPluginInputNodes: () => maximumPluginInputNodes,
+  maximumPluginNameLength: () => maximumPluginNameLength,
+  maximumPlugins: () => maximumPlugins,
+  resolve: () => resolve
+});
+module.exports = __toCommonJS(Resolve_exports);
+var ImmutableMap = __toESM(require("@smthrs/canonical/ReadonlyMap"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Config = __toESM(require("./Config.js"), 1);
+var import_Hooks = require("./Hooks.js");
+var Boundary = __toESM(require("./internal/Boundary.js"), 1);
+var import_mergePluginLayers = require("./internal/mergePluginLayers.js");
+var import_snapshotCacheEnvironment = require("./internal/snapshotCacheEnvironment.js");
+var import_PluginError = require("./PluginError.js");
+const maximumPluginDepth = 64;
+const maximumPlugins = 256;
+const maximumHandlers = 1024;
+const maximumPluginInputNodes = 4096;
+const maximumPluginNameLength = 256;
+const defaultParallelConcurrency = 16;
+const maximumParallelConcurrency = 256;
+const failure = (code, message, path, fields = {}) => new import_PluginError.PluginError({ code, message, path, ...fields });
+const invalidPlugin = (path, complaint, fields = {}) => failure("invalid_plugin", `plugin input ${complaint}`, path, fields);
+const diagnosticKey = (key) => key.length > 64 ? `${key.slice(0, 64)}...` : key;
+const childPath = (path, key) => {
+  const bounded = diagnosticKey(key);
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(bounded) ? `${path}.${bounded}` : `${path}[${JSON.stringify(bounded)}]`;
+};
+const ownData = (input, path, allowed) => {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw invalidPlugin(path, "must be an ordinary record");
+  }
+  const prototype = Object.getPrototypeOf(input);
+  if (prototype !== Object.prototype && prototype !== null) throw invalidPlugin(path, "must be an ordinary record");
+  const output = {};
+  for (const key of Reflect.ownKeys(input)) {
+    if (typeof key !== "string") throw invalidPlugin(path, "must not contain symbol keys");
+    if (allowed !== void 0 && !allowed.has(key)) {
+      throw invalidPlugin(childPath(path, key), "contains an unknown property");
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    if (descriptor === void 0 || !("value" in descriptor) || !descriptor.enumerable) {
+      throw invalidPlugin(childPath(path, key), "must be an enumerable data property");
+    }
+    Object.defineProperty(output, key, { value: descriptor.value, enumerable: true });
+  }
+  return output;
+};
+const snapshotOptions = (input) => {
+  const values = ownData(
+    input,
+    "$options",
+    /* @__PURE__ */ new Set(["config", "target", "hooks", "cacheEnvironment", "parallelConcurrency"])
+  );
+  return {
+    config: values.config,
+    target: values.target,
+    hooks: values.hooks,
+    cacheEnvironment: values.cacheEnvironment,
+    parallelConcurrency: values.parallelConcurrency
+  };
+};
+const validName = (value) => typeof value === "string" && value.length > 0 && value.length <= maximumPluginNameLength && Boundary.isWellFormedText(value) && !/^\s*$/u.test(value) && !/\p{Cc}/u.test(value);
+const snapshotCatalog = (input) => {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw invalidPlugin("$options.hooks", "must be an ordinary hook catalog");
+  }
+  const prototype = Object.getPrototypeOf(input);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw invalidPlugin("$options.hooks", "must be an ordinary hook catalog");
+  }
+  const output = {};
+  for (const key of Reflect.ownKeys(input)) {
+    if (typeof key !== "string" || !validName(key)) {
+      throw invalidPlugin("$options.hooks", "contains an invalid hook name");
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    if (descriptor === void 0 || !("value" in descriptor) || !descriptor.enumerable) {
+      throw invalidPlugin(childPath("$options.hooks", key), "must be an enumerable data property");
+    }
+    if (!["sequential", "parallel", "first", "waterfall"].includes(descriptor.value)) {
+      throw invalidPlugin(childPath("$options.hooks", key), "contains an invalid hook kind");
+    }
+    Object.defineProperty(output, key, { value: descriptor.value, enumerable: true });
+  }
+  for (const hook of Object.keys(import_Hooks.engineHooks)) {
+    if (Object.hasOwn(output, hook) && output[hook] !== import_Hooks.engineHooks[hook]) {
+      throw failure(
+        "hook_kind_mismatch",
+        `hook catalog declares shared hook ${JSON.stringify(hook)} as ${JSON.stringify(output[hook])}, the kernel dispatches it as ${JSON.stringify(import_Hooks.engineHooks[hook])}`,
+        childPath("$options.hooks", hook),
+        { hook }
+      );
+    }
+  }
+  return Object.freeze(output);
+};
+const snapshotHook = (entry, path, plugin, hook) => {
+  if (typeof entry === "function") return entry;
+  if (entry === void 0) {
+    throw invalidPlugin(path, "must be a function or a hook object", { plugin, hook });
+  }
+  const values = ownData(entry, path, /* @__PURE__ */ new Set(["order", "handler"]));
+  if (typeof values.handler !== "function") {
+    throw invalidPlugin(`${path}.handler`, "must be a function", { plugin, hook });
+  }
+  if (values.order !== void 0 && values.order !== "pre" && values.order !== "post") {
+    throw invalidPlugin(`${path}.order`, "must be pre or post", { plugin, hook });
+  }
+  return Object.freeze({
+    ...values.order === void 0 ? {} : { order: values.order },
+    handler: values.handler
+  });
+};
+const snapshotPlugin = (input, path) => {
+  const values = ownData(input, path, /* @__PURE__ */ new Set(["name", "version", "enforce", "apply", "layer", "hooks"]));
+  if (!validName(values.name)) throw invalidPlugin(`${path}.name`, "requires a bounded non-empty name");
+  const name = values.name;
+  if (values.version !== void 0 && !validName(values.version)) {
+    throw invalidPlugin(`${path}.version`, "requires a bounded non-empty version", { plugin: name });
+  }
+  if (values.enforce !== void 0 && values.enforce !== "pre" && values.enforce !== "post") {
+    throw invalidPlugin(`${path}.enforce`, "must be pre or post", { plugin: name });
+  }
+  if (values.apply !== void 0 && values.apply !== "engine" && values.apply !== "harness" && typeof values.apply !== "function") throw invalidPlugin(`${path}.apply`, "must be engine, harness, or a predicate", { plugin: name });
+  if (values.layer !== void 0 && !Layer.isLayer(values.layer)) {
+    throw invalidPlugin(`${path}.layer`, "must be an Effect Layer", { plugin: name });
+  }
+  let hooks;
+  if (values.hooks !== void 0) {
+    const rawHooks = ownData(values.hooks, `${path}.hooks`);
+    const snapshot = /* @__PURE__ */ Object.create(null);
+    for (const [index, hook] of Object.keys(rawHooks).entries()) {
+      if (!validName(hook)) {
+        throw invalidPlugin(`${path}.hooks[${index}]`, "contains an invalid hook name");
+      }
+      const entry = rawHooks[hook];
+      Object.defineProperty(snapshot, hook, {
+        value: snapshotHook(entry, childPath(`${path}.hooks`, hook), name, hook),
+        enumerable: true
+      });
+    }
+    hooks = Object.freeze(snapshot);
+  }
+  return Object.freeze({
+    name,
+    ...values.version === void 0 ? {} : { version: values.version },
+    ...values.enforce === void 0 ? {} : { enforce: values.enforce },
+    ...values.apply === void 0 ? {} : { apply: values.apply },
+    ...values.layer === void 0 ? {} : { layer: values.layer },
+    ...hooks === void 0 ? {} : { hooks }
+  });
+};
+const flatten = (input) => {
+  const output = [];
+  const arrays = /* @__PURE__ */ new WeakSet();
+  const stack = [
+    { value: input, path: "$", depth: 0 }
+  ];
+  let nodes = 0;
+  while (stack.length > 0) {
+    const current = stack.pop();
+    nodes += 1;
+    if (current.value === false || current.value === null || current.value === void 0) continue;
+    if (Array.isArray(current.value)) {
+      if (current.depth >= maximumPluginDepth) {
+        throw failure("resource_limit", `plugin input exceeds the depth limit of ${maximumPluginDepth}`, current.path);
+      }
+      if (arrays.has(current.value)) throw invalidPlugin(current.path, "contains a cycle or repeated preset array");
+      arrays.add(current.value);
+      const length = current.value.length;
+      if (length > maximumPluginInputNodes - nodes - stack.length) {
+        throw failure("resource_limit", `plugin input exceeds the ${maximumPluginInputNodes}-node limit`, current.path);
+      }
+      const keys = Reflect.ownKeys(current.value);
+      if (keys.length !== length + 1 || !keys.includes("length")) {
+        throw invalidPlugin(current.path, "must be a dense preset array with no extra properties");
+      }
+      for (let index = length - 1; index >= 0; index--) {
+        const descriptor = Object.getOwnPropertyDescriptor(current.value, String(index));
+        if (descriptor === void 0 || !("value" in descriptor) || !descriptor.enumerable) {
+          throw invalidPlugin(`${current.path}[${index}]`, "must be an enumerable data property");
+        }
+        stack.push({ value: descriptor.value, path: `${current.path}[${index}]`, depth: current.depth + 1 });
+      }
+      continue;
+    }
+    output.push(Object.freeze({ plugin: snapshotPlugin(current.value, current.path), path: current.path }));
+    if (output.length > maximumPlugins) {
+      throw failure("resource_limit", `plugin input exceeds the ${maximumPlugins}-plugin limit`, current.path);
+    }
+  }
+  return output;
+};
+const included = (plugin, config, target) => {
+  const apply = plugin.apply;
+  if (apply === void 0) return Effect.succeed(true);
+  if (typeof apply !== "function") return Effect.succeed(apply === target);
+  return Effect.try({
+    try: () => apply(config),
+    catch: () => failure("apply_failed", `plugin "${plugin.name}" apply predicate failed`, "$.apply", {
+      plugin: plugin.name
+    })
+  }).pipe(
+    Effect.flatMap(
+      (result) => typeof result === "boolean" ? Effect.succeed(result) : Effect.fail(invalidPlugin("$.apply", "predicate must return a boolean", { plugin: plugin.name }))
+    )
+  );
+};
+const rank = (enforce) => enforce === "pre" ? 0 : enforce === "post" ? 2 : 1;
+const resolve = (input, options = {}, configOverride) => Effect.gen(function* () {
+  const raw = yield* Effect.try({
+    try: () => snapshotOptions(options),
+    catch: (cause) => cause instanceof import_PluginError.PluginError ? cause : invalidPlugin("$options", "could not be inspected without executing user code")
+  });
+  if (configOverride !== void 0 && raw.config !== void 0) {
+    return yield* Effect.fail(invalidPlugin(
+      "$options.config",
+      "cannot declare config in options alongside the positional override"
+    ));
+  }
+  if (raw.target !== void 0 && raw.target !== "engine" && raw.target !== "harness") {
+    return yield* Effect.fail(invalidPlugin("$options.target", "must be engine or harness"));
+  }
+  if (raw.parallelConcurrency !== void 0 && (typeof raw.parallelConcurrency !== "number" || !Number.isSafeInteger(raw.parallelConcurrency) || raw.parallelConcurrency <= 0 || raw.parallelConcurrency > maximumParallelConcurrency)) {
+    return yield* Effect.fail(failure(
+      "resource_limit",
+      `parallel concurrency must be between 1 and ${maximumParallelConcurrency}`,
+      "$options.parallelConcurrency"
+    ));
+  }
+  const parallelConcurrency = raw.parallelConcurrency === void 0 ? defaultParallelConcurrency : raw.parallelConcurrency;
+  const config = yield* Config.snapshot(configOverride ?? raw.config ?? {});
+  const known = yield* Effect.try({
+    try: () => snapshotCatalog(raw.hooks ?? import_Hooks.engineHooks),
+    catch: (cause) => cause instanceof import_PluginError.PluginError ? cause : invalidPlugin("$options.hooks", "could not be inspected without executing user code")
+  });
+  const admitted = yield* Effect.try({
+    try: () => flatten(input),
+    catch: (cause) => cause instanceof import_PluginError.PluginError ? cause : invalidPlugin("$", "could not be inspected without executing user code")
+  });
+  const target = raw.target ?? "engine";
+  const selected = yield* Effect.filter(admitted, ({ plugin }) => included(plugin, config, target));
+  let handlerCount = 0;
+  for (const { path, plugin } of selected) {
+    const pluginHooks = plugin.hooks;
+    if (pluginHooks === void 0) continue;
+    for (const hook of Object.keys(pluginHooks)) {
+      if (!Object.hasOwn(known, hook)) {
+        return yield* Effect.fail(failure(
+          "unknown_hook",
+          `plugin ${JSON.stringify(plugin.name)} declares unknown hook ${JSON.stringify(diagnosticKey(hook))}`,
+          childPath(`${path}.hooks`, hook),
+          { plugin: plugin.name, hook }
+        ));
+      }
+      handlerCount += 1;
+      if (handlerCount > maximumHandlers) {
+        return yield* Effect.fail(failure(
+          "resource_limit",
+          `plugin handlers exceed the limit of ${maximumHandlers}`,
+          childPath(`${path}.hooks`, hook)
+        ));
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const { plugin } of selected) {
+    if (seen.has(plugin.name)) {
+      return yield* Effect.fail(failure(
+        "duplicate_name",
+        `duplicate plugin name "${plugin.name}"`,
+        "$.name",
+        { plugin: plugin.name }
+      ));
+    }
+    seen.add(plugin.name);
+  }
+  const plugins = Object.freeze(
+    selected.map(({ plugin }, index) => ({ plugin, index })).sort((left, right) => rank(left.plugin.enforce) - rank(right.plugin.enforce) || left.index - right.index).map(({ plugin }) => plugin)
+  );
+  const entries = [];
+  for (const hook of Object.keys(known)) {
+    const records = [];
+    for (const [index, plugin] of plugins.entries()) {
+      const pluginHooks = plugin.hooks;
+      if (pluginHooks === void 0 || !Object.hasOwn(pluginHooks, hook)) continue;
+      const entry = pluginHooks[hook];
+      const record = Object.freeze({ plugin: plugin.name, hook, handler: (0, import_Hooks.handlerOf)(entry) });
+      records.push({ record, enforceRank: rank(plugin.enforce), orderRank: rank((0, import_Hooks.orderOf)(entry)), index });
+    }
+    const ordered = records.sort(
+      (left, right) => left.orderRank - right.orderRank || left.enforceRank - right.enforceRank || left.index - right.index
+    ).map(({ record }) => record);
+    if (ordered.length > 0) entries.push([hook, Object.freeze(ordered)]);
+  }
+  const cacheEnvironment = yield* (0, import_snapshotCacheEnvironment.snapshotCacheEnvironment)(raw.cacheEnvironment, plugins);
+  return Object.freeze({
+    plugins,
+    handlers: ImmutableMap.make(entries),
+    kinds: known,
+    parallelConcurrency,
+    ...cacheEnvironment === void 0 ? {} : { cacheEnvironment }
+  });
+});
+const layer = (resolved) => (0, import_mergePluginLayers.mergePluginLayers)(resolved.plugins, resolved.cacheEnvironment);
+//# sourceMappingURL=Resolve.js.map