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

package/dist/cjs/Resolve.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Resolve.ts"],
+  "sourcesContent": ["/**\n * Bounded plugin resolution: admit, filter, validate, order, and snapshot.\n *\n * The resulting catalog owns every record it exposes. Dispatch never reads a\n * caller-owned map, plugin record, hook object, config value, or cache identity.\n *\n * @since 1.0.0-rc.0\n */\n\nimport * as ImmutableMap from \"@smthrs/canonical/ReadonlyMap\"\nimport type { Action } from \"@smthrs/flow\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport type { FlowsConfig } from \"./Config.ts\"\nimport * as Config from \"./Config.ts\"\nimport type { HookCatalog, HookKind, HookObject } from \"./Hooks.ts\"\nimport { engineHooks, handlerOf, orderOf } from \"./Hooks.ts\"\nimport type { FlowsHooks } from \"./index.ts\"\nimport * as Boundary from \"./internal/Boundary.ts\"\nimport { mergePluginLayers } from \"./internal/mergePluginLayers.ts\"\nimport { snapshotCacheEnvironment } from \"./internal/snapshotCacheEnvironment.ts\"\nimport type { Apply, FlowsPlugin, PluginInput } from \"./Plugin.ts\"\nimport { PluginError, type PluginErrorCode } from \"./PluginError.ts\"\n\n/**\n * Maximum nested preset-array depth accepted at startup.\n *\n * @category limits\n * @since 1.0.0-rc.0\n */\nexport const maximumPluginDepth = 64\n\n/**\n * Maximum plugins accepted by one kernel.\n *\n * @category limits\n * @since 1.0.0-rc.0\n */\nexport const maximumPlugins = 256\n\n/**\n * Maximum aggregate hook handlers accepted by one kernel.\n *\n * @category limits\n * @since 1.0.0-rc.0\n */\nexport const maximumHandlers = 1_024\n\n/**\n * Maximum input nodes, including arrays and omitted entries.\n *\n * @category limits\n * @since 1.0.0-rc.0\n */\nexport const maximumPluginInputNodes = 4_096\n\n/**\n * Maximum UTF-16 length of one plugin or hook name.\n *\n * @category limits\n * @since 1.0.0-rc.0\n */\nexport const maximumPluginNameLength = 256\n\n/**\n * Default fiber bound for parallel observers.\n *\n * @category limits\n * @since 1.0.0-rc.0\n */\nexport const defaultParallelConcurrency = 16\n\n/**\n * Maximum configurable parallel-observer bound.\n *\n * @category limits\n * @since 1.0.0-rc.0\n */\nexport const maximumParallelConcurrency = 256\n\n/**\n * One resolved handler with immutable attribution.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface HandlerRecord {\n  readonly plugin: string\n  readonly hook: string\n  readonly handler: (...args: Array<any>) => unknown\n}\n\n/**\n * The immutable output of plugin resolution.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface Resolved<H = FlowsHooks> {\n  readonly plugins: ReadonlyArray<FlowsPlugin<H>>\n  readonly handlers: ReadonlyMap<string, ReadonlyArray<HandlerRecord>>\n  /** The frozen runtime catalog this resolution admitted. Dispatch refuses a method whose kind differs from it. */\n  readonly kinds: Readonly<Record<string, HookKind>>\n  readonly parallelConcurrency: number\n  readonly cacheEnvironment?: Action.CacheEnvironment | undefined\n}\n\n/**\n * Options for {@link resolve}.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface Options<H = FlowsHooks> {\n  /** Pre-resolution config tested by `apply` predicates. */\n  readonly config?: FlowsConfig | undefined\n  /** Host whose literal `apply` selectors are active. Defaults to `\"engine\"`. */\n  readonly target?: \"engine\" | \"harness\" | undefined\n  /**\n   * Hook names recognized by this host, each with the kind `H` declares for\n   * it. The shared `config` and `configResolved` hooks are fixed to\n   * `waterfall` and `parallel`; another kind fails with `hook_kind_mismatch`.\n   */\n  readonly hooks?: HookCatalog<H> | undefined\n  /** Complete composition identity for sealed activity keys. Requires every selected plugin to have a version. */\n  readonly cacheEnvironment?: Action.CacheEnvironment | undefined\n  /** Maximum observers run at once. Defaults to 16 and cannot exceed 256. */\n  readonly parallelConcurrency?: number | undefined\n}\n\ninterface RawOptions {\n  readonly config: unknown\n  readonly target: unknown\n  readonly hooks: unknown\n  readonly cacheEnvironment: unknown\n  readonly parallelConcurrency: unknown\n}\n\nconst failure = (\n  code: PluginErrorCode,\n  message: string,\n  path: string,\n  fields: { readonly plugin?: string; readonly hook?: string } = {}\n): PluginError => new PluginError({ code, message, path, ...fields })\n\nconst invalidPlugin = (\n  path: string,\n  complaint: string,\n  fields: { readonly plugin?: string; readonly hook?: string } = {}\n): PluginError => failure(\"invalid_plugin\", `plugin input ${complaint}`, path, fields)\n\n// Bound before quoting or scanning caller-controlled keys. Keep Boundary's\n// identifier/dot and JSON-quoted/bracket path convention.\nconst diagnosticKey = (key: string): string => key.length > 64 ? `${key.slice(0, 64)}...` : key\n\nconst childPath = (path: string, key: string): string => {\n  const bounded = diagnosticKey(key)\n  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(bounded) ? `${path}.${bounded}` : `${path}[${JSON.stringify(bounded)}]`\n}\n\nconst ownData = (\n  input: unknown,\n  path: string,\n  allowed?: ReadonlySet<string>\n): Readonly<Record<string, unknown>> => {\n  if (typeof input !== \"object\" || input === null || Array.isArray(input)) {\n    throw invalidPlugin(path, \"must be an ordinary record\")\n  }\n  const prototype = Object.getPrototypeOf(input)\n  if (prototype !== Object.prototype && prototype !== null) throw invalidPlugin(path, \"must be an ordinary record\")\n  const output: Record<string, unknown> = {}\n  for (const key of Reflect.ownKeys(input)) {\n    if (typeof key !== \"string\") throw invalidPlugin(path, \"must not contain symbol keys\")\n    if (allowed !== undefined && !allowed.has(key)) {\n      throw invalidPlugin(childPath(path, key), \"contains an unknown property\")\n    }\n    const descriptor = Object.getOwnPropertyDescriptor(input, key)\n    if (descriptor === undefined || !(\"value\" in descriptor) || !descriptor.enumerable) {\n      throw invalidPlugin(childPath(path, key), \"must be an enumerable data property\")\n    }\n    Object.defineProperty(output, key, { value: descriptor.value, enumerable: true })\n  }\n  return output\n}\n\nconst snapshotOptions = (input: unknown): RawOptions => {\n  const values = ownData(\n    input,\n    \"$options\",\n    new Set([\"config\", \"target\", \"hooks\", \"cacheEnvironment\", \"parallelConcurrency\"])\n  )\n  return {\n    config: values.config,\n    target: values.target,\n    hooks: values.hooks,\n    cacheEnvironment: values.cacheEnvironment,\n    parallelConcurrency: values.parallelConcurrency\n  }\n}\n\nconst validName = (value: unknown): value is string =>\n  typeof value === \"string\" && value.length > 0 && value.length <= maximumPluginNameLength &&\n  Boundary.isWellFormedText(value) && !/^\\s*$/u.test(value) && !/\\p{Cc}/u.test(value)\n\nconst snapshotCatalog = (input: unknown): Readonly<Record<string, HookKind>> => {\n  if (typeof input !== \"object\" || input === null || Array.isArray(input)) {\n    throw invalidPlugin(\"$options.hooks\", \"must be an ordinary hook catalog\")\n  }\n  const prototype = Object.getPrototypeOf(input)\n  if (prototype !== Object.prototype && prototype !== null) {\n    throw invalidPlugin(\"$options.hooks\", \"must be an ordinary hook catalog\")\n  }\n  const output: Record<string, HookKind> = {}\n  for (const key of Reflect.ownKeys(input)) {\n    if (typeof key !== \"string\" || !validName(key)) {\n      throw invalidPlugin(\"$options.hooks\", \"contains an invalid hook name\")\n    }\n    const descriptor = Object.getOwnPropertyDescriptor(input, key)\n    if (descriptor === undefined || !(\"value\" in descriptor) || !descriptor.enumerable) {\n      throw invalidPlugin(childPath(\"$options.hooks\", key), \"must be an enumerable data property\")\n    }\n    if (!([\"sequential\", \"parallel\", \"first\", \"waterfall\"] as ReadonlyArray<unknown>).includes(descriptor.value)) {\n      throw invalidPlugin(childPath(\"$options.hooks\", key), \"contains an invalid hook kind\")\n    }\n    Object.defineProperty(output, key, { value: descriptor.value, enumerable: true })\n  }\n  for (const hook of Object.keys(engineHooks) as ReadonlyArray<keyof typeof engineHooks>) {\n    if (Object.hasOwn(output, hook) && output[hook] !== engineHooks[hook]) {\n      throw failure(\n        \"hook_kind_mismatch\",\n        `hook catalog declares shared hook ${JSON.stringify(hook)} as ${\n          JSON.stringify(output[hook])\n        }, the kernel dispatches it as ${JSON.stringify(engineHooks[hook])}`,\n        childPath(\"$options.hooks\", hook),\n        { hook }\n      )\n    }\n  }\n  return Object.freeze(output)\n}\n\nconst snapshotHook = (\n  entry: unknown,\n  path: string,\n  plugin: string,\n  hook: string\n): ((...args: Array<any>) => unknown) | HookObject<(...args: Array<any>) => unknown> => {\n  if (typeof entry === \"function\") return entry as (...args: Array<any>) => unknown\n  if (entry === undefined) {\n    throw invalidPlugin(path, \"must be a function or a hook object\", { plugin, hook })\n  }\n  const values = ownData(entry, path, new Set([\"order\", \"handler\"]))\n  if (typeof values.handler !== \"function\") {\n    throw invalidPlugin(`${path}.handler`, \"must be a function\", { plugin, hook })\n  }\n  if (values.order !== undefined && values.order !== \"pre\" && values.order !== \"post\") {\n    throw invalidPlugin(`${path}.order`, \"must be pre or post\", { plugin, hook })\n  }\n  return Object.freeze({\n    ...(values.order === undefined ? {} : { order: values.order }),\n    handler: values.handler\n  }) as HookObject<(...args: Array<any>) => unknown>\n}\n\nconst snapshotPlugin = <H>(\n  input: unknown,\n  path: string\n): FlowsPlugin<H> => {\n  const values = ownData(input, path, new Set([\"name\", \"version\", \"enforce\", \"apply\", \"layer\", \"hooks\"]))\n  if (!validName(values.name)) throw invalidPlugin(`${path}.name`, \"requires a bounded non-empty name\")\n  const name = values.name\n  if (values.version !== undefined && !validName(values.version)) {\n    throw invalidPlugin(`${path}.version`, \"requires a bounded non-empty version\", { plugin: name })\n  }\n  if (values.enforce !== undefined && values.enforce !== \"pre\" && values.enforce !== \"post\") {\n    throw invalidPlugin(`${path}.enforce`, \"must be pre or post\", { plugin: name })\n  }\n  if (\n    values.apply !== undefined && values.apply !== \"engine\" && values.apply !== \"harness\" &&\n    typeof values.apply !== \"function\"\n  ) throw invalidPlugin(`${path}.apply`, \"must be engine, harness, or a predicate\", { plugin: name })\n  if (values.layer !== undefined && !Layer.isLayer(values.layer)) {\n    throw invalidPlugin(`${path}.layer`, \"must be an Effect Layer\", { plugin: name })\n  }\n\n  let hooks: Readonly<Record<string, unknown>> | undefined\n  if (values.hooks !== undefined) {\n    const rawHooks = ownData(values.hooks, `${path}.hooks`)\n    const snapshot: Record<string, unknown> = Object.create(null)\n    for (const [index, hook] of Object.keys(rawHooks).entries()) {\n      if (!validName(hook)) {\n        throw invalidPlugin(`${path}.hooks[${index}]`, \"contains an invalid hook name\")\n      }\n      const entry = rawHooks[hook]\n      Object.defineProperty(snapshot, hook, {\n        value: snapshotHook(entry, childPath(`${path}.hooks`, hook), name, hook),\n        enumerable: true\n      })\n    }\n    hooks = Object.freeze(snapshot)\n  }\n\n  return Object.freeze({\n    name,\n    ...(values.version === undefined ? {} : { version: values.version }),\n    ...(values.enforce === undefined ? {} : { enforce: values.enforce }),\n    ...(values.apply === undefined ? {} : { apply: values.apply as Apply }),\n    ...(values.layer === undefined ? {} : { layer: values.layer as Layer.Layer<never, any, any> }),\n    ...(hooks === undefined ? {} : { hooks: hooks as Partial<H> })\n  })\n}\n\ninterface AdmittedPlugin<H> {\n  readonly plugin: FlowsPlugin<H>\n  readonly path: string\n}\n\nconst flatten = <H>(input: unknown): ReadonlyArray<AdmittedPlugin<H>> => {\n  const output: Array<AdmittedPlugin<H>> = []\n  const arrays = new WeakSet<object>()\n  const stack: Array<{ readonly value: unknown; readonly path: string; readonly depth: number }> = [\n    { value: input, path: \"$\", depth: 0 }\n  ]\n  let nodes = 0\n  while (stack.length > 0) {\n    const current = stack.pop()!\n    nodes += 1\n    if (current.value === false || current.value === null || current.value === undefined) continue\n    if (Array.isArray(current.value)) {\n      if (current.depth >= maximumPluginDepth) {\n        throw failure(\"resource_limit\", `plugin input exceeds the depth limit of ${maximumPluginDepth}`, current.path)\n      }\n      if (arrays.has(current.value)) throw invalidPlugin(current.path, \"contains a cycle or repeated preset array\")\n      arrays.add(current.value)\n      const length = current.value.length\n      // Every queued frame and array element costs a node, including omitted\n      // entries. Refuse before enumerating keys, descriptors, or child frames.\n      if (length > maximumPluginInputNodes - nodes - stack.length) {\n        throw failure(\"resource_limit\", `plugin input exceeds the ${maximumPluginInputNodes}-node limit`, current.path)\n      }\n      const keys = Reflect.ownKeys(current.value)\n      if (keys.length !== length + 1 || !keys.includes(\"length\")) {\n        throw invalidPlugin(current.path, \"must be a dense preset array with no extra properties\")\n      }\n      for (let index = length - 1; index >= 0; index--) {\n        const descriptor = Object.getOwnPropertyDescriptor(current.value, String(index))\n        if (descriptor === undefined || !(\"value\" in descriptor) || !descriptor.enumerable) {\n          throw invalidPlugin(`${current.path}[${index}]`, \"must be an enumerable data property\")\n        }\n        stack.push({ value: descriptor.value, path: `${current.path}[${index}]`, depth: current.depth + 1 })\n      }\n      continue\n    }\n    output.push(Object.freeze({ plugin: snapshotPlugin<H>(current.value, current.path), path: current.path }))\n    if (output.length > maximumPlugins) {\n      throw failure(\"resource_limit\", `plugin input exceeds the ${maximumPlugins}-plugin limit`, current.path)\n    }\n  }\n  return output\n}\n\nconst included = <H>(\n  plugin: FlowsPlugin<H>,\n  config: FlowsConfig,\n  target: \"engine\" | \"harness\"\n): Effect.Effect<boolean, PluginError> => {\n  const apply = plugin.apply\n  if (apply === undefined) return Effect.succeed(true)\n  if (typeof apply !== \"function\") return Effect.succeed(apply === target)\n  return Effect.try({\n    try: () => apply(config),\n    catch: () =>\n      failure(\"apply_failed\", `plugin \"${plugin.name}\" apply predicate failed`, \"$.apply\", {\n        plugin: plugin.name\n      })\n  }).pipe(\n    Effect.flatMap((result) =>\n      typeof result === \"boolean\"\n        ? Effect.succeed(result)\n        : Effect.fail(invalidPlugin(\"$.apply\", \"predicate must return a boolean\", { plugin: plugin.name }))\n    )\n  )\n}\n\nconst rank = (enforce: \"pre\" | \"post\" | undefined): number => (enforce === \"pre\" ? 0 : enforce === \"post\" ? 2 : 1)\n\n/**\n * Resolves a plugin preset into an immutable, resource-bounded catalog.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n */\nexport const resolve = <H = FlowsHooks>(\n  input: PluginInput<NoInfer<H>>,\n  options: Options<NoInfer<H>> = {},\n  configOverride?: FlowsConfig\n): Effect.Effect<Resolved<H>, PluginError> =>\n  Effect.gen(function*() {\n    const raw = yield* Effect.try({\n      try: () => snapshotOptions(options),\n      catch: (cause) =>\n        cause instanceof PluginError\n          ? cause\n          : invalidPlugin(\"$options\", \"could not be inspected without executing user code\")\n    })\n    if (configOverride !== undefined && raw.config !== undefined) {\n      return yield* Effect.fail(invalidPlugin(\n        \"$options.config\",\n        \"cannot declare config in options alongside the positional override\"\n      ))\n    }\n    if (raw.target !== undefined && raw.target !== \"engine\" && raw.target !== \"harness\") {\n      return yield* Effect.fail(invalidPlugin(\"$options.target\", \"must be engine or harness\"))\n    }\n    if (\n      raw.parallelConcurrency !== undefined &&\n      (typeof raw.parallelConcurrency !== \"number\" || !Number.isSafeInteger(raw.parallelConcurrency) ||\n        raw.parallelConcurrency <= 0 ||\n        raw.parallelConcurrency > maximumParallelConcurrency)\n    ) {\n      return yield* Effect.fail(failure(\n        \"resource_limit\",\n        `parallel concurrency must be between 1 and ${maximumParallelConcurrency}`,\n        \"$options.parallelConcurrency\"\n      ))\n    }\n    const parallelConcurrency = raw.parallelConcurrency === undefined\n      ? defaultParallelConcurrency\n      : raw.parallelConcurrency\n    const config = yield* Config.snapshot(configOverride ?? raw.config ?? {})\n    const known = yield* Effect.try({\n      try: () => snapshotCatalog(raw.hooks ?? engineHooks),\n      catch: (cause) =>\n        cause instanceof PluginError\n          ? cause\n          : invalidPlugin(\"$options.hooks\", \"could not be inspected without executing user code\")\n    })\n    const admitted = yield* Effect.try({\n      try: () => flatten<H>(input),\n      catch: (cause) =>\n        cause instanceof PluginError\n          ? cause\n          : invalidPlugin(\"$\", \"could not be inspected without executing user code\")\n    })\n    const target = raw.target ?? \"engine\"\n    const selected = yield* Effect.filter(admitted, ({ plugin }) => included(plugin, config, target))\n\n    let handlerCount = 0\n    for (const { path, plugin } of selected) {\n      const pluginHooks = plugin.hooks as Readonly<Record<string, unknown>> | undefined\n      if (pluginHooks === undefined) continue\n      for (const hook of Object.keys(pluginHooks)) {\n        if (!Object.hasOwn(known, hook)) {\n          return yield* Effect.fail(failure(\n            \"unknown_hook\",\n            `plugin ${JSON.stringify(plugin.name)} declares unknown hook ${JSON.stringify(diagnosticKey(hook))}`,\n            childPath(`${path}.hooks`, hook),\n            { plugin: plugin.name, hook }\n          ))\n        }\n        handlerCount += 1\n        if (handlerCount > maximumHandlers) {\n          return yield* Effect.fail(failure(\n            \"resource_limit\",\n            `plugin handlers exceed the limit of ${maximumHandlers}`,\n            childPath(`${path}.hooks`, hook)\n          ))\n        }\n      }\n    }\n\n    const seen = new Set<string>()\n    for (const { plugin } of selected) {\n      if (seen.has(plugin.name)) {\n        return yield* Effect.fail(failure(\n          \"duplicate_name\",\n          `duplicate plugin name \"${plugin.name}\"`,\n          \"$.name\",\n          { plugin: plugin.name }\n        ))\n      }\n      seen.add(plugin.name)\n    }\n\n    const plugins = Object.freeze(\n      selected\n        .map(({ plugin }, index) => ({ plugin, index }))\n        .sort((left, right) => rank(left.plugin.enforce) - rank(right.plugin.enforce) || left.index - right.index)\n        .map(({ plugin }) => plugin)\n    )\n    const entries: Array<readonly [string, ReadonlyArray<HandlerRecord>]> = []\n    for (const hook of Object.keys(known)) {\n      const records: Array<{\n        readonly record: HandlerRecord\n        readonly enforceRank: number\n        readonly orderRank: number\n        readonly index: number\n      }> = []\n      for (const [index, plugin] of plugins.entries()) {\n        const pluginHooks = plugin.hooks as Readonly<Record<string, unknown>> | undefined\n        if (pluginHooks === undefined || !Object.hasOwn(pluginHooks, hook)) continue\n        const entry = pluginHooks[hook]\n        const record = Object.freeze({ plugin: plugin.name, hook, handler: handlerOf(entry) })\n        records.push({ record, enforceRank: rank(plugin.enforce), orderRank: rank(orderOf(entry)), index })\n      }\n      // Vite's rule, verbatim: the per-hook `order` is the outer partition and\n      // the enforce-sorted plugin list supplies the stable order inside it, so a\n      // hook marked `order: \"pre\"` runs ahead of every normal-order handler even\n      // when its plugin is `enforce: \"post\"`.\n      const ordered = records\n        .sort((left, right) =>\n          left.orderRank - right.orderRank || left.enforceRank - right.enforceRank || left.index - right.index\n        )\n        .map(({ record }) => record)\n      if (ordered.length > 0) entries.push([hook, Object.freeze(ordered)])\n    }\n    const cacheEnvironment = yield* snapshotCacheEnvironment(raw.cacheEnvironment, plugins)\n    return Object.freeze({\n      plugins,\n      handlers: ImmutableMap.make(entries),\n      kinds: known,\n      parallelConcurrency,\n      ...(cacheEnvironment === undefined ? {} : { cacheEnvironment })\n    })\n  })\n\n/**\n * Merges every resolved plugin layer left-to-right and supplies the detached\n * cache environment captured during resolution.\n *\n * @category combinators\n * @since 1.0.0-rc.0\n */\nexport const layer = <H>(resolved: Resolved<H>): Layer.Layer<any, PluginError, any> =>\n  mergePluginLayers(resolved.plugins, resolved.cacheEnvironment)\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The bounded cell-host plugin kernel: typed hooks, resolution and ordering,
+ * and the config pipeline.
+ *
+ * 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`. Durable
+ * engine extension remains dependency injection; this package does not expose
+ * an engine-wide lifecycle registry.
+ *
+ * @since 1.0.0-rc.0
+ */
+import type * as Effect from "effect/Effect";
+import type { FlowsConfig, ResolvedConfig } from "./Config.ts";
+import type { ParallelHook, WaterfallHook } from "./Hooks.ts";
+/**
+ * The shared kernel's base hook catalog.
+ *
+ * Declared here, in the package entry point, so that the documented
+ * augmentation specifier works: an interface can only be augmented in the
+ * module that declares it:
+ *
+ * ```ts
+ * declare module "@smthrs/plugin" {
+ *   interface FlowsHooks {
+ *     toolCall: SequentialHook<(ctx: ToolCallContext) => Effect.Effect<Option.Option<ToolOverride>>>
+ *   }
+ * }
+ * ```
+ *
+ * Closed for dispatch, open for augmentation: the kernel dispatches only the
+ * config lifecycle below; a host supplies and dispatches its own catalog over
+ * the same augmented interface.
+ *
+ * Both startup hooks are context-free: `Kernel.make` runs them before any
+ * plugin layer exists and supplies no services of its own, so a handler that
+ * needs a service provides it inside the hook. A host whose startup hooks do
+ * require services declares a separate hook interface, and `Kernel.make` then
+ * surfaces those requirements as `Kernel.StartupContext<H>`.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface FlowsHooks {
+    readonly config: WaterfallHook<(config: FlowsConfig) => Effect.Effect<Partial<FlowsConfig> | void, any, never>>;
+    readonly configResolved: ParallelHook<(config: ResolvedConfig) => Effect.Effect<void, any, never>>;
+}
+/**
+ * @since 1.0.0-rc.0
+ * @category config
+ */
+export * as Config from "./Config.ts";
+/**
+ * @since 1.0.0-rc.0
+ * @category hooks
+ */
+export * from "./Hooks.ts";
+/**
+ * @since 1.0.0-rc.0
+ * @category startup
+ */
+export * as Kernel from "./Kernel.ts";
+/**
+ * @since 1.0.0-rc.0
+ * @category models
+ */
+export * from "./Plugin.ts";
+/**
+ * @since 1.0.0-rc.0
+ * @category errors
+ */
+export * from "./PluginError.ts";
+/**
+ * @since 1.0.0-rc.0
+ * @category dispatch
+ */
+export * as Plugins from "./Plugins.ts";
+/**
+ * @since 1.0.0-rc.0
+ * @category resolution
+ */
+export * as Resolve from "./Resolve.ts";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,MAAM,EAAE,WAAW,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAA;IAC/G,QAAQ,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC,MAAM,EAAE,cAAc,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAA;CACnG;AAED;;;GAGG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;GAGG;AACH,cAAc,YAAY,CAAA;AAE1B;;;GAGG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;GAGG;AACH,cAAc,aAAa,CAAA;AAE3B;;;GAGG;AACH,cAAc,kBAAkB,CAAA;AAEhC;;;GAGG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;GAGG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA"}

package/dist/cjs/index.js

@@ -0,0 +1,45 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 index_exports = {};
+__export(index_exports, {
+  Config: () => Config,
+  Kernel: () => Kernel,
+  Plugins: () => Plugins,
+  Resolve: () => Resolve
+});
+module.exports = __toCommonJS(index_exports);
+var Config = __toESM(require("./Config.js"), 1);
+__reExport(index_exports, require("./Hooks.js"), module.exports);
+var Kernel = __toESM(require("./Kernel.js"), 1);
+__reExport(index_exports, require("./Plugin.js"), module.exports);
+__reExport(index_exports, require("./PluginError.js"), module.exports);
+var Plugins = __toESM(require("./Plugins.js"), 1);
+var Resolve = __toESM(require("./Resolve.js"), 1);
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": ["/**\n * The bounded cell-host plugin kernel: typed hooks, resolution and ordering,\n * and the config pipeline.\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`. Durable\n * engine extension remains dependency injection; this package does not expose\n * an engine-wide lifecycle registry.\n *\n * @since 1.0.0-rc.0\n */\n\nimport type * as Effect from \"effect/Effect\"\nimport type { FlowsConfig, ResolvedConfig } from \"./Config.ts\"\nimport type { ParallelHook, WaterfallHook } from \"./Hooks.ts\"\n\n/**\n * The shared kernel's base hook catalog.\n *\n * Declared here, in the package entry point, so that the documented\n * augmentation specifier works: an interface can only be augmented in the\n * module that declares it:\n *\n * ```ts\n * declare module \"@smthrs/plugin\" {\n *   interface FlowsHooks {\n *     toolCall: SequentialHook<(ctx: ToolCallContext) => Effect.Effect<Option.Option<ToolOverride>>>\n *   }\n * }\n * ```\n *\n * Closed for dispatch, open for augmentation: the kernel dispatches only the\n * config lifecycle below; a host supplies and dispatches its own catalog over\n * the same augmented interface.\n *\n * Both startup hooks are context-free: `Kernel.make` runs them before any\n * plugin layer exists and supplies no services of its own, so a handler that\n * needs a service provides it inside the hook. A host whose startup hooks do\n * require services declares a separate hook interface, and `Kernel.make` then\n * surfaces those requirements as `Kernel.StartupContext<H>`.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface FlowsHooks {\n  readonly config: WaterfallHook<(config: FlowsConfig) => Effect.Effect<Partial<FlowsConfig> | void, any, never>>\n  readonly configResolved: ParallelHook<(config: ResolvedConfig) => Effect.Effect<void, any, never>>\n}\n\n/**\n * @since 1.0.0-rc.0\n * @category config\n */\nexport * as Config from \"./Config.ts\"\n\n/**\n * @since 1.0.0-rc.0\n * @category hooks\n */\nexport * from \"./Hooks.ts\"\n\n/**\n * @since 1.0.0-rc.0\n * @category startup\n */\nexport * as Kernel from \"./Kernel.ts\"\n\n/**\n * @since 1.0.0-rc.0\n * @category models\n */\nexport * from \"./Plugin.ts\"\n\n/**\n * @since 1.0.0-rc.0\n * @category errors\n */\nexport * from \"./PluginError.ts\"\n\n/**\n * @since 1.0.0-rc.0\n * @category dispatch\n */\nexport * as Plugins from \"./Plugins.ts\"\n\n/**\n * @since 1.0.0-rc.0\n * @category resolution\n */\nexport * as Resolve from \"./Resolve.ts\"\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsDA,aAAwB;AAMxB,0BAAc,uBA5Dd;AAkEA,aAAwB;AAMxB,0BAAc,wBAxEd;AA8EA,0BAAc,6BA9Ed;AAoFA,cAAyB;AAMzB,cAAyB;",
+  "names": []
+}

package/dist/cjs/internal/Boundary.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Inert JSON admission for plugin configuration and cache identity.
+ *
+ * Reflection is descriptor-only: accessors never execute, hostile proxies are
+ * refused, and accepted values are detached before they are frozen.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+import * as BoundedJson from "@smthrs/canonical/BoundedJson";
+/**
+ * Strict JSON value accepted by the boundary.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export type Json = BoundedJson.Json;
+/**
+ * Resource bounds for one admitted tree.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export type Limits = BoundedJson.StrictLimits;
+/**
+ * Successful admission.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export interface AdmissionSuccess {
+    readonly ok: true;
+    readonly value: Json;
+}
+/**
+ * Refusal with a stable value path.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export interface AdmissionFailure {
+    readonly ok: false;
+    readonly path: string;
+    readonly complaint: string;
+}
+/**
+ * Result of inert JSON admission.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export type Admission = AdmissionSuccess | AdmissionFailure;
+/**
+ * Default configuration bounds.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export declare const defaultLimits: Limits;
+/**
+ * Tests whether a string contains paired UTF-16 surrogate units.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export declare const isWellFormedText: (value: string) => boolean;
+/**
+ * Copies one strict JSON tree under explicit resource bounds.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export declare const admit: (input: unknown, limits?: Limits) => Admission;
+/**
+ * Admits only a JSON record at the root.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export declare const record: (input: unknown, limits?: Limits) => AdmissionSuccess | AdmissionFailure;
+/**
+ * Merges two independently admitted records, retaining unchanged subtrees.
+ * Both operands must come from successful admission, and the patch must be a
+ * fresh copy: their trees must be disjoint. Each output branch then comes from
+ * at most one location in either tree, preserving the no-repeated-reference
+ * invariant without walking retained subtrees. Limits apply to the result.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export declare const mergeRecords: (base: {
+    readonly [key: string]: Json;
+}, patch: {
+    readonly [key: string]: Json;
+}, limits?: Limits) => Admission;
+//# sourceMappingURL=Boundary.d.ts.map

package/dist/cjs/internal/Boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Boundary.d.ts","sourceRoot":"","sources":["../../../src/internal/Boundary.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,WAAW,MAAM,+BAA+B,CAAA;AAE5D;;;;;GAKG;AACH,MAAM,MAAM,IAAI,GAAG,WAAW,CAAC,IAAI,CAAA;AAEnC;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,WAAW,CAAC,YAAY,CAAA;AAE7C;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAA;IACjB,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;CACrB;AAED;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAA;IAClB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,gBAAgB,GAAG,gBAAgB,CAAA;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,aAAa,EAAE,MAO1B,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,KAAG,OAA+B,CAAA;AA4EhF;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,OAAO,EAAE,SAAQ,MAAsB,KAAG,SAatE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GACjB,OAAO,OAAO,EACd,SAAQ,MAAsB,KAC7B,gBAAgB,GAAG,gBAKrB,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,GACvB,MAAM;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACtC,OAAO;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACvC,SAAQ,MAAsB,KAC7B,SA4CF,CAAA"}

package/dist/cjs/internal/Boundary.js

@@ -0,0 +1,129 @@
+"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 Boundary_exports = {};
+__export(Boundary_exports, {
+  admit: () => admit,
+  defaultLimits: () => defaultLimits,
+  isWellFormedText: () => isWellFormedText,
+  mergeRecords: () => mergeRecords,
+  record: () => record
+});
+module.exports = __toCommonJS(Boundary_exports);
+var BoundedJson = __toESM(require("@smthrs/canonical/BoundedJson"), 1);
+const defaultLimits = Object.freeze({
+  maxBytes: 1024 * 1024,
+  maxDepth: 64,
+  maxMembers: 4096,
+  maxNodes: 8192,
+  maxStringBytes: 64 * 1024,
+  maxKeyBytes: 1024
+});
+const isWellFormedText = (value) => value.isWellFormed();
+const childPath = (path, key) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? `${path}.${key}` : `${path}[${JSON.stringify(key)}]`;
+const encodedStringBytes = (value) => BoundedJson.encodedStringBytes(value);
+const boundedPath = (path) => {
+  let bytes = 2 + 3;
+  let prefix = "";
+  for (const character of path) {
+    const point = character.codePointAt(0);
+    bytes += character === '"' || character === "\\" ? 2 : point <= 127 ? 1 : point <= 2047 ? 2 : point <= 65535 ? 3 : 4;
+    if (bytes > 192) return `${prefix}...`;
+    prefix += character;
+  }
+  return path;
+};
+const snapshots = /* @__PURE__ */ new WeakMap();
+const scalarTotals = (bytes) => ({ bytes, members: 0, nodes: 1, depth: 0 });
+const total = (entries) => {
+  const totals = { bytes: 2 + Math.max(0, entries.size - 1), members: entries.size, nodes: 1, depth: 1 };
+  for (const entry of entries.values()) {
+    totals.bytes += entry.keyBytes + entry.totals.bytes;
+    totals.members += entry.totals.members;
+    totals.nodes += entry.totals.nodes;
+    totals.depth = Math.max(totals.depth, 1 + entry.totals.depth);
+  }
+  return totals;
+};
+const remember = (value) => {
+  const entries = /* @__PURE__ */ new Map();
+  for (const [key, child] of Object.entries(value)) {
+    entries.set(key, {
+      keyBytes: Array.isArray(value) ? 0 : encodedStringBytes(key) + 1,
+      totals: typeof child === "object" && child !== null ? snapshots.get(child).totals : scalarTotals(typeof child === "string" ? encodedStringBytes(child) : String(child).length)
+    });
+  }
+  snapshots.set(value, { totals: total(entries), entries });
+};
+const admit = (input, limits = defaultLimits) => {
+  const result = BoundedJson.admitStrict(input, limits, {
+    ordinaryRecords: true,
+    boundedText: true,
+    onContainer: remember
+  });
+  return result.ok ? result : {
+    ...result,
+    path: boundedPath(result.path),
+    complaint: result.complaint === "must be dense and have no extra properties" ? "must be a dense array with no extra properties" : result.complaint
+  };
+};
+const record = (input, limits = defaultLimits) => {
+  const admitted = admit(input, limits);
+  return admitted.ok && (admitted.value === null || Array.isArray(admitted.value) || typeof admitted.value !== "object") ? { ok: false, path: "$", complaint: "must be a JSON record" } : admitted;
+};
+const mergeRecords = (base, patch, limits = defaultLimits) => {
+  const merge = (left, right, path) => {
+    const entries = new Map(snapshots.get(left).entries);
+    const result = { ...left };
+    for (const [key, entry] of snapshots.get(right).entries) {
+      const previous = left[key];
+      const next = right[key];
+      if (typeof previous === "object" && previous !== null && !Array.isArray(previous) && typeof next === "object" && next !== null && !Array.isArray(next)) {
+        const merged = merge(
+          previous,
+          next,
+          childPath(path, key)
+        );
+        if (!merged.ok) return merged;
+        result[key] = merged.value;
+        entries.set(key, { keyBytes: entry.keyBytes, totals: snapshots.get(merged.value).totals });
+      } else {
+        result[key] = next;
+        entries.set(key, entry);
+      }
+    }
+    const totals = total(entries);
+    const complaint = totals.members > limits.maxMembers ? `exceeds the ${limits.maxMembers}-member limit` : totals.nodes > limits.maxNodes ? `exceeds the ${limits.maxNodes}-node limit` : totals.bytes > limits.maxBytes ? `exceeds the ${limits.maxBytes}-byte limit` : totals.depth > limits.maxDepth ? `exceeds the depth limit of ${limits.maxDepth}` : void 0;
+    if (complaint !== void 0) return { ok: false, path: boundedPath(path), complaint };
+    Object.freeze(result);
+    snapshots.set(result, { totals, entries });
+    return { ok: true, value: result };
+  };
+  return merge(base, patch, "$");
+};
+//# sourceMappingURL=Boundary.js.map

package/dist/cjs/internal/Boundary.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Boundary.ts"],
+  "sourcesContent": ["/**\n * Inert JSON admission for plugin configuration and cache identity.\n *\n * Reflection is descriptor-only: accessors never execute, hostile proxies are\n * refused, and accepted values are detached before they are frozen.\n *\n * @private\n * @since 1.0.0-rc.0\n */\n\nimport * as BoundedJson from \"@smthrs/canonical/BoundedJson\"\n\n/**\n * Strict JSON value accepted by the boundary.\n *\n * @private\n * @since 1.0.0-rc.0\n */\nexport type Json = BoundedJson.Json\n\n/**\n * Resource bounds for one admitted tree.\n *\n * @private\n * @since 1.0.0-rc.0\n */\nexport type Limits = BoundedJson.StrictLimits\n\n/**\n * Successful admission.\n *\n * @private\n * @since 1.0.0-rc.0\n */\nexport interface AdmissionSuccess {\n  readonly ok: true\n  readonly value: Json\n}\n\n/**\n * Refusal with a stable value path.\n *\n * @private\n * @since 1.0.0-rc.0\n */\nexport interface AdmissionFailure {\n  readonly ok: false\n  readonly path: string\n  readonly complaint: string\n}\n\n/**\n * Result of inert JSON admission.\n *\n * @private\n * @since 1.0.0-rc.0\n */\nexport type Admission = AdmissionSuccess | AdmissionFailure\n\n/**\n * Default configuration bounds.\n *\n * @private\n * @since 1.0.0-rc.0\n */\nexport const defaultLimits: Limits = Object.freeze({\n  maxBytes: 1024 * 1024,\n  maxDepth: 64,\n  maxMembers: 4_096,\n  maxNodes: 8_192,\n  maxStringBytes: 64 * 1024,\n  maxKeyBytes: 1_024\n})\n\n/**\n * Tests whether a string contains paired UTF-16 surrogate units.\n *\n * @private\n * @since 1.0.0-rc.0\n */\nexport const isWellFormedText = (value: string): boolean => value.isWellFormed()\n\nconst childPath = (path: string, key: string): string =>\n  /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? `${path}.${key}` : `${path}[${JSON.stringify(key)}]`\n\nconst encodedStringBytes = (value: string): number => BoundedJson.encodedStringBytes(value)!\n\n// Paths contain only well-formed text and JSON-escaped keys. Count their JSON\n// bytes without encoding the whole path, reserving quotes and a truncation marker.\nconst boundedPath = (path: string): string => {\n  let bytes = 2 + 3\n  let prefix = \"\"\n  for (const character of path) {\n    const point = character.codePointAt(0)!\n    bytes += character === \"\\\"\" || character === \"\\\\\"\n      ? 2\n      : point <= 0x7f\n      ? 1\n      : point <= 0x7ff\n      ? 2\n      : point <= 0xffff\n      ? 3\n      : 4\n    if (bytes > 192) return `${prefix}...`\n    prefix += character\n  }\n  return path\n}\n\ninterface Totals {\n  bytes: number\n  members: number\n  nodes: number\n  depth: number\n}\n\ninterface Entry {\n  readonly keyBytes: number\n  readonly totals: Totals\n}\n\ninterface Snapshot {\n  readonly totals: Totals\n  readonly entries: Map<string, Entry>\n}\n\n// Only detached containers constructed here enter this map. Mutable caller\n// objects and Object.freeze alone never establish admission.\nconst snapshots = new WeakMap<object, Snapshot>()\n\nconst scalarTotals = (bytes: number): Totals => ({ bytes, members: 0, nodes: 1, depth: 0 })\n\nconst total = (entries: ReadonlyMap<string, Entry>): Totals => {\n  const totals: Totals = { bytes: 2 + Math.max(0, entries.size - 1), members: entries.size, nodes: 1, depth: 1 }\n  for (const entry of entries.values()) {\n    totals.bytes += entry.keyBytes + entry.totals.bytes\n    totals.members += entry.totals.members\n    totals.nodes += entry.totals.nodes\n    totals.depth = Math.max(totals.depth, 1 + entry.totals.depth)\n  }\n  return totals\n}\n\nconst remember = (value: ReadonlyArray<Json> | { readonly [key: string]: Json }): void => {\n  const entries = new Map<string, Entry>()\n  for (const [key, child] of Object.entries(value)) {\n    entries.set(key, {\n      keyBytes: Array.isArray(value) ? 0 : encodedStringBytes(key) + 1,\n      totals: typeof child === \"object\" && child !== null ?\n        snapshots.get(child)!.totals\n        : scalarTotals(typeof child === \"string\" ? encodedStringBytes(child) : String(child).length)\n    })\n  }\n  snapshots.set(value, { totals: total(entries), entries })\n}\n\n/**\n * Copies one strict JSON tree under explicit resource bounds.\n *\n * @private\n * @since 1.0.0-rc.0\n */\nexport const admit = (input: unknown, limits: Limits = defaultLimits): Admission => {\n  const result = BoundedJson.admitStrict(input, limits, {\n    ordinaryRecords: true,\n    boundedText: true,\n    onContainer: remember\n  })\n  return result.ok ? result : {\n    ...result,\n    path: boundedPath(result.path),\n    complaint: result.complaint === \"must be dense and have no extra properties\"\n      ? \"must be a dense array with no extra properties\" :\n      result.complaint\n  }\n}\n\n/**\n * Admits only a JSON record at the root.\n *\n * @private\n * @since 1.0.0-rc.0\n */\nexport const record = (\n  input: unknown,\n  limits: Limits = defaultLimits\n): AdmissionSuccess | AdmissionFailure => {\n  const admitted = admit(input, limits)\n  return admitted.ok && (admitted.value === null || Array.isArray(admitted.value) || typeof admitted.value !== \"object\")\n    ? { ok: false, path: \"$\", complaint: \"must be a JSON record\" }\n    : admitted\n}\n\n/**\n * Merges two independently admitted records, retaining unchanged subtrees.\n * Both operands must come from successful admission, and the patch must be a\n * fresh copy: their trees must be disjoint. Each output branch then comes from\n * at most one location in either tree, preserving the no-repeated-reference\n * invariant without walking retained subtrees. Limits apply to the result.\n *\n * @private\n * @since 1.0.0-rc.0\n */\nexport const mergeRecords = (\n  base: { readonly [key: string]: Json },\n  patch: { readonly [key: string]: Json },\n  limits: Limits = defaultLimits\n): Admission => {\n  const merge = (\n    left: { readonly [key: string]: Json },\n    right: { readonly [key: string]: Json },\n    path: string\n  ): Admission => {\n    const entries = new Map(snapshots.get(left)!.entries)\n    const result = { ...left }\n    for (const [key, entry] of snapshots.get(right)!.entries) {\n      const previous = left[key]\n      const next = right[key]!\n      if (\n        typeof previous === \"object\" && previous !== null && !Array.isArray(previous) &&\n        typeof next === \"object\" && next !== null && !Array.isArray(next)\n      ) {\n        const merged = merge(\n          previous as { readonly [key: string]: Json },\n          next as { readonly [key: string]: Json },\n          childPath(path, key)\n        )\n        if (!merged.ok) return merged\n        result[key] = merged.value\n        entries.set(key, { keyBytes: entry.keyBytes, totals: snapshots.get(merged.value as object)!.totals })\n      } else {\n        result[key] = next\n        entries.set(key, entry)\n      }\n    }\n    const totals = total(entries)\n    const complaint = totals.members > limits.maxMembers ?\n      `exceeds the ${limits.maxMembers}-member limit`\n      : totals.nodes > limits.maxNodes ?\n      `exceeds the ${limits.maxNodes}-node limit`\n      : totals.bytes > limits.maxBytes ?\n      `exceeds the ${limits.maxBytes}-byte limit`\n      : totals.depth > limits.maxDepth ?\n      `exceeds the depth limit of ${limits.maxDepth}`\n      : undefined\n    if (complaint !== undefined) return { ok: false, path: boundedPath(path), complaint }\n    Object.freeze(result)\n    snapshots.set(result, { totals, entries })\n    return { ok: true, value: result }\n  }\n  return merge(base, patch, \"$\")\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/internal/mergePluginLayers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Effect layer composition for a resolved plugin list.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+import { Action } from "@smthrs/flow";
+import * as Layer from "effect/Layer";
+import type { FlowsPlugin } from "../Plugin.ts";
+import { PluginError } from "../PluginError.ts";
+/**
+ * Merges plugin layers left-to-right, wrapping each build failure as
+ * `layer_failed`, then seals the cache environment: it is supplied beneath
+ * the plugin layers and overrides anything they output, and an absent
+ * declaration stays absent.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export declare const mergePluginLayers: <H>(plugins: ReadonlyArray<FlowsPlugin<H>>, cacheEnvironment: Action.CacheEnvironment | undefined) => Layer.Layer<any, PluginError, any>;
+//# sourceMappingURL=mergePluginLayers.d.ts.map

package/dist/cjs/internal/mergePluginLayers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergePluginLayers.d.ts","sourceRoot":"","sources":["../../../src/internal/mergePluginLayers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAE/C;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,EACjC,SAAS,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EACtC,kBAAkB,MAAM,CAAC,gBAAgB,GAAG,SAAS,KACpD,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,CA+BnC,CAAA"}

package/dist/cjs/internal/mergePluginLayers.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 mergePluginLayers_exports = {};
+__export(mergePluginLayers_exports, {
+  mergePluginLayers: () => mergePluginLayers
+});
+module.exports = __toCommonJS(mergePluginLayers_exports);
+var import_flow = require("@smthrs/flow");
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var import_PluginError = require("../PluginError.js");
+const mergePluginLayers = (plugins, cacheEnvironment) => {
+  const layers = plugins.flatMap(
+    (plugin) => plugin.layer ? [
+      Layer.catchCause(plugin.layer, (cause) => Layer.effectDiscard(
+        Effect.fail(
+          new import_PluginError.PluginError({
+            code: "layer_failed",
+            message: `plugin "${plugin.name}" failed to build its layer`,
+            plugin: plugin.name,
+            cause
+          })
+        )
+      ))
+    ] : []
+  );
+  const merged = layers.length === 0 ? Layer.empty : layers.reduce((accumulated, next) => Layer.provideMerge(next, accumulated));
+  const environment = Layer.succeed(import_flow.Action.CurrentCacheEnvironment)(cacheEnvironment);
+  return Layer.merge(Layer.provideMerge(merged, environment), environment);
+};
+//# sourceMappingURL=mergePluginLayers.js.map

package/dist/cjs/internal/mergePluginLayers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/mergePluginLayers.ts"],
+  "sourcesContent": ["/**\n * Effect layer composition for a resolved plugin list.\n *\n * @private\n * @since 1.0.0-rc.0\n */\n\nimport { Action } from \"@smthrs/flow\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport type { FlowsPlugin } from \"../Plugin.ts\"\nimport { PluginError } from \"../PluginError.ts\"\n\n/**\n * Merges plugin layers left-to-right, wrapping each build failure as\n * `layer_failed`, then seals the cache environment: it is supplied beneath\n * the plugin layers and overrides anything they output, and an absent\n * declaration stays absent.\n *\n * @private\n * @since 1.0.0-rc.0\n */\nexport const mergePluginLayers = <H>(\n  plugins: ReadonlyArray<FlowsPlugin<H>>,\n  cacheEnvironment: Action.CacheEnvironment | undefined\n): Layer.Layer<any, PluginError, any> => {\n  const layers = plugins.flatMap((plugin) =>\n    plugin.layer\n      ? [\n        Layer.catchCause(plugin.layer, (cause) =>\n          Layer.effectDiscard(\n            Effect.fail(\n              new PluginError({\n                code: \"layer_failed\",\n                message: `plugin \"${plugin.name}\" failed to build its layer`,\n                plugin: plugin.name,\n                cause\n              })\n            )\n          )) as Layer.Layer<any, PluginError, any>\n      ]\n      : []\n  )\n  const merged = (layers.length === 0\n    ? Layer.empty\n    : layers.reduce((accumulated, next) => Layer.provideMerge(next, accumulated))) as Layer.Layer<any, PluginError, any>\n  // The sealed environment is provided beneath the plugin layers so they can\n  // read it, then merged last so it overrides any plugin output. An absent\n  // declaration is sealed as `undefined`, so no plugin layer can declare or\n  // replace the composition's cache identity.\n  const environment = Layer.succeed(Action.CurrentCacheEnvironment)(cacheEnvironment) as unknown as Layer.Layer<\n    any,\n    PluginError,\n    any\n  >\n  return Layer.merge(Layer.provideMerge(merged, environment), environment)\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,kBAAuB;AACvB,aAAwB;AACxB,YAAuB;AAEvB,yBAA4B;AAWrB,MAAM,oBAAoB,CAC/B,SACA,qBACuC;AACvC,QAAM,SAAS,QAAQ;AAAA,IAAQ,CAAC,WAC9B,OAAO,QACH;AAAA,MACA,MAAM,WAAW,OAAO,OAAO,CAAC,UAC9B,MAAM;AAAA,QACJ,OAAO;AAAA,UACL,IAAI,+BAAY;AAAA,YACd,MAAM;AAAA,YACN,SAAS,WAAW,OAAO,IAAI;AAAA,YAC/B,QAAQ,OAAO;AAAA,YACf;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF,CAAC;AAAA,IACL,IACE,CAAC;AAAA,EACP;AACA,QAAM,SAAU,OAAO,WAAW,IAC9B,MAAM,QACN,OAAO,OAAO,CAAC,aAAa,SAAS,MAAM,aAAa,MAAM,WAAW,CAAC;AAK9E,QAAM,cAAc,MAAM,QAAQ,mBAAO,uBAAuB,EAAE,gBAAgB;AAKlF,SAAO,MAAM,MAAM,MAAM,aAAa,QAAQ,WAAW,GAAG,WAAW;AACzE;",
+  "names": []
+}

package/dist/cjs/internal/snapshotCacheEnvironment.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Cache identity admission for a resolved plugin list.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+import { Action } from "@smthrs/flow";
+import * as Effect from "effect/Effect";
+import type { FlowsPlugin } from "../Plugin.ts";
+import { PluginError } from "../PluginError.ts";
+/**
+ * Admits a caller cache environment and prepends one escaped `name@version`
+ * identity per plugin, in resolved order. An absent input stays absent.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export declare const snapshotCacheEnvironment: <H>(input: unknown, plugins: ReadonlyArray<FlowsPlugin<H>>) => Effect.Effect<Action.CacheEnvironment | undefined, PluginError>;
+//# sourceMappingURL=snapshotCacheEnvironment.d.ts.map

package/dist/cjs/internal/snapshotCacheEnvironment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshotCacheEnvironment.d.ts","sourceRoot":"","sources":["../../../src/internal/snapshotCacheEnvironment.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAO/C;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GAAI,CAAC,EACxC,OAAO,OAAO,EACd,SAAS,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,KACrC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,gBAAgB,GAAG,SAAS,EAAE,WAAW,CAgDhE,CAAA"}