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

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,23 @@
+/**
+ * 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. A
+ * versionless plugin is refused at the dollar-path it was admitted from.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export declare const snapshotCacheEnvironment: <H>(input: unknown, plugins: ReadonlyArray<{
+    readonly plugin: FlowsPlugin<H>;
+    readonly path: string;
+}>) => 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;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,GAAI,CAAC,EACxC,OAAO,OAAO,EACd,SAAS,aAAa,CAAC;IAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,KACjF,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,gBAAgB,GAAG,SAAS,EAAE,WAAW,CAgDhE,CAAA"}

package/dist/cjs/internal/snapshotCacheEnvironment.js

@@ -0,0 +1,92 @@
+"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 snapshotCacheEnvironment_exports = {};
+__export(snapshotCacheEnvironment_exports, {
+  snapshotCacheEnvironment: () => snapshotCacheEnvironment
+});
+module.exports = __toCommonJS(snapshotCacheEnvironment_exports);
+var import_flow = require("@smthrs/flow");
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var import_PluginError = require("../PluginError.js");
+var Boundary = __toESM(require("./Boundary.js"), 1);
+const escapePluginIdentityPart = (value) => (
+  // Percent must be escaped first so literal escape-looking text remains distinct from the `@` escape added next.
+  value.replaceAll("%", "%25").replaceAll("@", "%40")
+);
+const snapshotCacheEnvironment = (input, plugins) => {
+  if (input === void 0) return Effect.succeed(void 0);
+  const pluginIdentities = [];
+  for (const { path, plugin } of plugins) {
+    if (plugin.version === void 0) {
+      return Effect.fail(
+        new import_PluginError.PluginError({
+          code: "cache_environment_invalid",
+          message: `cache environment requires a version for plugin "${plugin.name}"`,
+          path: `${path}.version`,
+          plugin: plugin.name
+        })
+      );
+    }
+    pluginIdentities.push(`${escapePluginIdentityPart(plugin.name)}@${escapePluginIdentityPart(plugin.version)}`);
+  }
+  const admitted = Boundary.record(input);
+  if (!admitted.ok) {
+    return Effect.fail(
+      new import_PluginError.PluginError({
+        code: "cache_environment_invalid",
+        message: `cache environment ${admitted.complaint}`,
+        path: `$options.cacheEnvironment${admitted.path.slice(1)}`
+      })
+    );
+  }
+  return Schema.decodeUnknownEffect(import_flow.Action.CacheEnvironment)(admitted.value).pipe(
+    Effect.mapError(
+      () => new import_PluginError.PluginError({
+        code: "cache_environment_invalid",
+        message: "cache environment does not match the complete cache identity schema",
+        path: "$options.cacheEnvironment"
+      })
+    ),
+    Effect.map((environment) => {
+      const capabilities = {};
+      for (const name of Object.keys(environment.capabilities)) {
+        Object.defineProperty(capabilities, name, {
+          value: Object.freeze([...environment.capabilities[name]]),
+          enumerable: true
+        });
+      }
+      return Object.freeze({
+        layers: Object.freeze([...pluginIdentities, ...environment.layers]),
+        capabilities: Object.freeze(capabilities)
+      });
+    })
+  );
+};
+//# sourceMappingURL=snapshotCacheEnvironment.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/snapshotCacheEnvironment.ts"],
+  "sourcesContent": ["/**\n * Cache identity admission 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 Schema from \"effect/Schema\"\nimport type { FlowsPlugin } from \"../Plugin.ts\"\nimport { PluginError } from \"../PluginError.ts\"\nimport * as Boundary from \"./Boundary.ts\"\n\nconst escapePluginIdentityPart = (value: string): string =>\n  // Percent must be escaped first so literal escape-looking text remains distinct from the `@` escape added next.\n  value.replaceAll(\"%\", \"%25\").replaceAll(\"@\", \"%40\")\n\n/**\n * Admits a caller cache environment and prepends one escaped `name@version`\n * identity per plugin, in resolved order. An absent input stays absent. A\n * versionless plugin is refused at the dollar-path it was admitted from.\n *\n * @private\n * @since 1.0.0-rc.0\n */\nexport const snapshotCacheEnvironment = <H>(\n  input: unknown,\n  plugins: ReadonlyArray<{ readonly plugin: FlowsPlugin<H>; readonly path: string }>\n): Effect.Effect<Action.CacheEnvironment | undefined, PluginError> => {\n  if (input === undefined) return Effect.succeed(undefined)\n  const pluginIdentities: Array<string> = []\n  for (const { path, plugin } of plugins) {\n    if (plugin.version === undefined) {\n      return Effect.fail(\n        new PluginError({\n          code: \"cache_environment_invalid\",\n          message: `cache environment requires a version for plugin \"${plugin.name}\"`,\n          path: `${path}.version`,\n          plugin: plugin.name\n        })\n      )\n    }\n    pluginIdentities.push(`${escapePluginIdentityPart(plugin.name)}@${escapePluginIdentityPart(plugin.version)}`)\n  }\n  const admitted = Boundary.record(input)\n  if (!admitted.ok) {\n    return Effect.fail(\n      new PluginError({\n        code: \"cache_environment_invalid\",\n        message: `cache environment ${admitted.complaint}`,\n        path: `$options.cacheEnvironment${admitted.path.slice(1)}`\n      })\n    )\n  }\n  return Schema.decodeUnknownEffect(Action.CacheEnvironment)(admitted.value).pipe(\n    Effect.mapError(() =>\n      new PluginError({\n        code: \"cache_environment_invalid\",\n        message: \"cache environment does not match the complete cache identity schema\",\n        path: \"$options.cacheEnvironment\"\n      })\n    ),\n    Effect.map((environment) => {\n      const capabilities: Record<string, ReadonlyArray<string>> = {}\n      for (const name of Object.keys(environment.capabilities)) {\n        Object.defineProperty(capabilities, name, {\n          value: Object.freeze([...environment.capabilities[name]!]),\n          enumerable: true\n        })\n      }\n      return Object.freeze({\n        layers: Object.freeze([...pluginIdentities, ...environment.layers]),\n        capabilities: Object.freeze(capabilities)\n      })\n    })\n  )\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,kBAAuB;AACvB,aAAwB;AACxB,aAAwB;AAExB,yBAA4B;AAC5B,eAA0B;AAE1B,MAAM,2BAA2B,CAAC;AAAA;AAAA,EAEhC,MAAM,WAAW,KAAK,KAAK,EAAE,WAAW,KAAK,KAAK;AAAA;AAU7C,MAAM,2BAA2B,CACtC,OACA,YACoE;AACpE,MAAI,UAAU,OAAW,QAAO,OAAO,QAAQ,MAAS;AACxD,QAAM,mBAAkC,CAAC;AACzC,aAAW,EAAE,MAAM,OAAO,KAAK,SAAS;AACtC,QAAI,OAAO,YAAY,QAAW;AAChC,aAAO,OAAO;AAAA,QACZ,IAAI,+BAAY;AAAA,UACd,MAAM;AAAA,UACN,SAAS,oDAAoD,OAAO,IAAI;AAAA,UACxE,MAAM,GAAG,IAAI;AAAA,UACb,QAAQ,OAAO;AAAA,QACjB,CAAC;AAAA,MACH;AAAA,IACF;AACA,qBAAiB,KAAK,GAAG,yBAAyB,OAAO,IAAI,CAAC,IAAI,yBAAyB,OAAO,OAAO,CAAC,EAAE;AAAA,EAC9G;AACA,QAAM,WAAW,SAAS,OAAO,KAAK;AACtC,MAAI,CAAC,SAAS,IAAI;AAChB,WAAO,OAAO;AAAA,MACZ,IAAI,+BAAY;AAAA,QACd,MAAM;AAAA,QACN,SAAS,qBAAqB,SAAS,SAAS;AAAA,QAChD,MAAM,4BAA4B,SAAS,KAAK,MAAM,CAAC,CAAC;AAAA,MAC1D,CAAC;AAAA,IACH;AAAA,EACF;AACA,SAAO,OAAO,oBAAoB,mBAAO,gBAAgB,EAAE,SAAS,KAAK,EAAE;AAAA,IACzE,OAAO;AAAA,MAAS,MACd,IAAI,+BAAY;AAAA,QACd,MAAM;AAAA,QACN,SAAS;AAAA,QACT,MAAM;AAAA,MACR,CAAC;AAAA,IACH;AAAA,IACA,OAAO,IAAI,CAAC,gBAAgB;AAC1B,YAAM,eAAsD,CAAC;AAC7D,iBAAW,QAAQ,OAAO,KAAK,YAAY,YAAY,GAAG;AACxD,eAAO,eAAe,cAAc,MAAM;AAAA,UACxC,OAAO,OAAO,OAAO,CAAC,GAAG,YAAY,aAAa,IAAI,CAAE,CAAC;AAAA,UACzD,YAAY;AAAA,QACd,CAAC;AAAA,MACH;AACA,aAAO,OAAO,OAAO;AAAA,QACnB,QAAQ,OAAO,OAAO,CAAC,GAAG,kBAAkB,GAAG,YAAY,MAAM,CAAC;AAAA,QAClE,cAAc,OAAO,OAAO,YAAY;AAAA,MAC1C,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AACF;",
+  "names": []
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/esm/Config.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Bounded JSON configuration consumed and produced by the plugin kernel.
+ *
+ * Configuration is an extension namespace, not an engine-policy surface.
+ * Durable retry, concurrency, and storage policy stay on their owning Effect
+ * services and constructor options. Every accepted value is copied before any
+ * plugin observes it, then frozen recursively.
+ *
+ * @since 1.0.0-rc.0
+ */
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { PluginError } from "./PluginError.ts";
+/**
+ * Maximum encoded bytes accepted for one plugin configuration.
+ *
+ * @category limits
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumConfigBytes: number;
+/**
+ * Maximum nesting accepted for one plugin configuration.
+ *
+ * @category limits
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumConfigDepth: number;
+/**
+ * Maximum aggregate members accepted for one plugin configuration.
+ *
+ * @category limits
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumConfigMembers: number;
+/**
+ * Maximum aggregate values accepted for one plugin configuration.
+ *
+ * @category limits
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumConfigNodes: number;
+/**
+ * One value accepted in a plugin-owned configuration namespace.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export declare const ConfigValue: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+/**
+ * One value accepted in a plugin-owned configuration namespace.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type ConfigValue = typeof ConfigValue.Type;
+/**
+ * Admits pre-resolution configuration as a detached, recursively frozen snapshot.
+ *
+ * Keys name plugin-owned namespaces. `engine`, `retry`, `store`, and
+ * `plugins` are refused because accepting those names would imply policy the
+ * plugin kernel does not own or apply.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export declare const FlowsConfig: Schema.decodeTo<Schema.declare<Readonly<Record<string, Schema.Json>>, Readonly<Record<string, Schema.Json>>>, Schema.Unknown, never, never>;
+/**
+ * The decoded form of {@link FlowsConfig}.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type FlowsConfig = typeof FlowsConfig.Type;
+/**
+ * Admits the detached, recursively frozen configuration handed to plugins.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export declare const ResolvedConfig: Schema.decodeTo<Schema.declare<Readonly<Record<string, Schema.Json>>, Readonly<Record<string, Schema.Json>>>, Schema.Unknown, never, never>;
+/**
+ * The decoded form of {@link ResolvedConfig}.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type ResolvedConfig = typeof ResolvedConfig.Type;
+/**
+ * Empty defaults. Engine policy is deliberately not defaulted here.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const defaults: ResolvedConfig;
+/**
+ * Copies and deep-merges a configuration patch over a base configuration.
+ *
+ * Records merge key-by-key and every other JSON value replaces wholesale.
+ * Raw operands are admitted; known snapshots retain unchanged subtrees.
+ * Cached subtree totals enforce merged output bounds. Unsafe property names,
+ * accessors, cycles, exotic prototypes, and aggregate values outside the
+ * resource limits fail with `config_invalid`.
+ *
+ * @category combinators
+ * @since 1.0.0-rc.0
+ */
+export declare const merge: (base: FlowsConfig, patch: unknown) => FlowsConfig;
+/**
+ * Copies and freezes one JSON value without retaining caller-owned objects.
+ *
+ * @category utils
+ * @since 1.0.0-rc.0
+ */
+export declare const deepFreeze: <A extends ConfigValue>(value: A) => A;
+/**
+ * Admits a raw pre-resolution configuration as an immutable snapshot.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const snapshot: (config: unknown) => Effect.Effect<FlowsConfig, PluginError>;
+/**
+ * Decodes the post-waterfall configuration into its final immutable form.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const resolve: (config: unknown) => Effect.Effect<ResolvedConfig, PluginError>;
+//# sourceMappingURL=Config.d.ts.map

package/dist/esm/Config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../src/Config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,QAAkC,CAAA;AAEjE;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,QAAkC,CAAA;AAEjE;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,QAAoC,CAAA;AAErE;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,QAAkC,CAAA;AAEjE;;;;;GAKG;AACH,eAAO,MAAM,WAAW,sDAAc,CAAA;AAEtC;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AAwBjD;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,6IAAsB,CAAA;AAE9C;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,cAAc,6IAAsB,CAAA;AAEjD;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAyBvD;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,EAAE,cAAmC,CAAA;AAE1D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,KAAK,GAAI,MAAM,WAAW,EAAE,OAAO,OAAO,KAAG,WAUzD,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,WAAW,EAAE,OAAO,CAAC,KAAG,CAI5D,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,QAAQ,OAAO,KAAG,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,WAAW,CACU,CAAA;AAE3F;;;;;GAKG;AACH,eAAO,MAAM,OAAO,GAAI,QAAQ,OAAO,KAAG,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,WAAW,CAAqB,CAAA"}