@xandreed/runtime 0.12.0 → 0.14.0

package/README.md

@@ -1,5 +1,5 @@
 # @xandreed/runtime
 
-Efferent composable agent framework, 0.12.0. Node 24 or Bun.
+Efferent composable agent framework, 0.14.0. Node 24 or Bun.
 
 Documentation: https://github.com/xandreeddev/efferent

package/dist/index.d.ts

@@ -1,4 +1,2 @@
 export * from "./graph.js";
-export * from "./config.js";
-export * from "./plugins.js";
 export * from "./live-layer.adapter.js";

package/dist/index.js

@@ -1,4 +1,2 @@
 export * from "./graph.js";
-export * from "./config.js";
-export * from "./plugins.js";
 export * from "./live-layer.adapter.js";

package/dist/live-layer.adapter.js

@@ -1,8 +1,8 @@
 import { Context, Effect, Exit, Ref, Scope, Semaphore } from "effect";
 import * as Layers from "effect/Layer";
-import { HarnessError } from "@xandreed/core";
+import { HarnessError, replayableContext } from "@xandreed/core";
 export const makeLiveLayer = (initial) => Effect.gen(function* () {
-  const dependencies = yield* Effect.context(), gate = yield* Semaphore.make(1), generations = yield* Ref.make(new Map), current = yield* Ref.make(0), closed = yield* Ref.make(!1), unavailable = () => new HarnessError({ code: "module.closed", message: "Module registry is closed" }), stage = (layer, id) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+  const dependencies = replayableContext(yield* Effect.context()), gate = yield* Semaphore.make(1), generations = yield* Ref.make(new Map), current = yield* Ref.make(0), closed = yield* Ref.make(!1), unavailable = () => new HarnessError({ code: "module.closed", message: "Module registry is closed" }), stage = (layer, id) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
     const scope = yield* Scope.make(), memoMap = yield* Layers.makeMemoMap, services = yield* restore(Layers.buildWithMemoMap(layer, memoMap, scope).pipe(Effect.provide(dependencies))).pipe(Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(scope, exit) : Effect.void));
     return { id, services, scope, leases: 0, retired: !1 };
   })), first = yield* stage(initial, 0);

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "@xandreed/runtime",
-  "version": "0.12.0",
+  "version": "0.14.0",
+  "engines": {
+    "node": ">=24",
+    "bun": ">=1.3.0"
+  },
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
@@ -10,8 +14,8 @@
     }
   },
   "dependencies": {
-    "@xandreed/core": "0.12.0",
-    "effect": "4.0.0-rc.118"
+    "@xandreed/core": "0.14.0",
+    "effect": "4.0.7"
   },
   "private": false,
   "types": "./dist/index.d.ts",
@@ -22,9 +26,5 @@
     "README.md",
     "LICENSE"
   ],
-  "engines": {
-    "node": ">=24",
-    "bun": ">=1.3.0"
-  },
   "license": "MIT"
 }

package/dist/config.d.ts

@@ -1,88 +0,0 @@
-import { Effect } from "effect";
-import { HarnessConfig, HarnessError } from "@xandreed/core";
-import type { Plugin } from "@xandreed/core";
-export interface ConfigSource {
-    readonly path: string;
-    readonly config: HarnessConfig;
-    readonly plugins?: ReadonlyArray<Plugin>;
-}
-export declare const mergeConfig: (base: HarnessConfig, overlay: HarnessConfig) => HarnessConfig;
-export declare const decodeConfig: (input: unknown, source: string) => Effect.Effect<HarnessConfig, HarnessError>;
-export declare const loadConfig: (options: {
-    readonly workspace: string;
-    readonly home: string;
-    readonly preset: HarnessConfig;
-    readonly profile?: string;
-    readonly invocation?: HarnessConfig;
-}) => Effect.Effect<{
-    config: {
-        profile: string;
-        version: 1;
-        system?: string | undefined;
-        plugins?: readonly {
-            readonly id: string;
-            readonly use: string;
-            readonly options?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-            readonly enabled?: boolean | undefined;
-        }[] | undefined;
-        bindings?: {
-            readonly [x: string]: string;
-        } | undefined;
-        profiles?: {
-            readonly [x: string]: {
-                readonly system?: string | undefined;
-                readonly plugins?: readonly {
-                    readonly id: string;
-                    readonly use: string;
-                    readonly options?: {
-                        readonly [x: string]: unknown;
-                    } | undefined;
-                    readonly enabled?: boolean | undefined;
-                }[] | undefined;
-                readonly bindings?: {
-                    readonly [x: string]: string;
-                } | undefined;
-            };
-        } | undefined;
-    };
-    sources: {
-        path: string;
-        config: {
-            readonly version: 1;
-            readonly system?: string | undefined;
-            readonly plugins?: readonly {
-                readonly id: string;
-                readonly use: string;
-                readonly options?: {
-                    readonly [x: string]: unknown;
-                } | undefined;
-                readonly enabled?: boolean | undefined;
-            }[] | undefined;
-            readonly bindings?: {
-                readonly [x: string]: string;
-            } | undefined;
-            readonly profile?: string | undefined;
-            readonly profiles?: {
-                readonly [x: string]: {
-                    readonly system?: string | undefined;
-                    readonly plugins?: readonly {
-                        readonly id: string;
-                        readonly use: string;
-                        readonly options?: {
-                            readonly [x: string]: unknown;
-                        } | undefined;
-                        readonly enabled?: boolean | undefined;
-                    }[] | undefined;
-                    readonly bindings?: {
-                        readonly [x: string]: string;
-                    } | undefined;
-                };
-            } | undefined;
-        };
-    }[];
-    plugins: Plugin[];
-}, HarnessError, never>;
-export declare const writeConfig: (path: string, config: HarnessConfig) => Effect.Effect<void, HarnessError, never>;
-export declare const redact: (value: unknown) => unknown;

package/dist/config.js

@@ -1,50 +0,0 @@
-import { access, mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { Effect, Option, Schema } from "effect";
-import { HarnessConfig, HarnessError } from "@xandreed/core";
-const mergeEntries = (left, right) => right.reduce((entries, incoming) => {
-  const old = entries.find((entry) => entry.id === incoming.id), next = old === void 0 || old.use !== incoming.use ? incoming : {
-    ...old,
-    ...incoming,
-    options: { ...old.options, ...incoming.options }
-  };
-  return old === void 0 ? [...entries, next] : entries.map((entry) => entry.id === incoming.id ? next : entry);
-}, left);
-export const mergeConfig = (base, overlay) => ({
-  ...base,
-  ...overlay,
-  plugins: mergeEntries(base.plugins ?? [], overlay.plugins ?? []),
-  bindings: { ...base.bindings, ...overlay.bindings },
-  profiles: { ...base.profiles, ...overlay.profiles }
-}), decodeConfig = (input, source) => Schema.decodeUnknownEffect(HarnessConfig)(input, { onExcessProperty: "error", reportInput: !0 }).pipe(Effect.mapError((error) => new HarnessError({ code: "config.invalid", message: `${source}: ${String(error)}` })));
-const io = (action, label) => Effect.tryPromise({
-  try: action,
-  catch: (error) => new HarnessError({ code: "config.io", message: `${label}: ${String(error)}` })
-}), exists = (path) => Effect.tryPromise({ try: () => access(path), catch: () => !1 }).pipe(Effect.as(!0), Effect.orElseSucceed(() => !1)), readJson = (path) => io(() => readFile(path, "utf8"), path).pipe(Effect.flatMap((text) => Schema.decodeUnknownEffect(Schema.fromJsonString(HarnessConfig))(text, { onExcessProperty: "error", reportInput: !0 })), Effect.mapError((error) => new HarnessError({ code: "config.invalid", message: `${path}: ${String(error)}` }))), readBase = (directory) => Effect.gen(function* () {
-  const json = join(directory, "efferent.config.json"), ts = join(directory, "efferent.config.ts"), found = yield* Effect.filter([json, ts], exists);
-  if (found.length > 1)
-    return yield* Effect.fail(new HarnessError({ code: "config.ambiguous", message: `Choose one base configuration in ${directory}: JSON or TypeScript` }));
-  const path = found[0];
-  if (path === void 0)
-    return Option.none();
-  if (!path.endsWith(".ts"))
-    return Option.some({ path, config: yield* readJson(path) });
-  const module = yield* io(() => import(`${pathToFileURL(path).href}?revision=${Date.now()}`), path), config = yield* decodeConfig(module.default, path), plugins = module.plugins ?? [];
-  if (!Array.isArray(plugins) || plugins.some((value) => typeof value !== "object" || value === null || !("build" in value) || typeof value.build !== "function" || !("id" in value) || typeof value.id !== "string"))
-    return yield* Effect.fail(new HarnessError({ code: "config.plugins", message: `${path}: plugins must be an array of definePlugin definitions` }));
-  return Option.some({ path, config, plugins });
-});
-export const loadConfig = (options) => Effect.gen(function* () {
-  const sources = (yield* Effect.forEach([join(options.home, ".efferent"), options.workspace], readBase)).flatMap(Option.toArray), combined = sources.reduce((config, source) => mergeConfig(config, source.config), options.preset), profileName = options.profile ?? combined.profile ?? "smith", profile = combined.profiles?.[profileName];
-  if (profile === void 0 && profileName !== "smith")
-    return yield* Effect.fail(new HarnessError({ code: "config.profile", message: `Unknown profile: ${profileName}` }));
-  const selected = profile === void 0 ? combined : mergeConfig(combined, { version: 1, ...profile }), overridesPath = join(options.workspace, ".efferent", "overrides.json"), override = (yield* exists(overridesPath)) ? yield* readJson(overridesPath) : { version: 1 }, allSources = [...sources, { path: `profile:${profileName}`, config: { version: 1, ...profile } }, { path: overridesPath, config: override }];
-  return { config: { ...mergeConfig(mergeConfig(selected, override), options.invocation ?? { version: 1 }), profile: profileName }, sources: allSources.map(({ path, config }) => ({ path, config })), plugins: sources.flatMap((source) => source.plugins ?? []) };
-}), writeConfig = (path, config) => decodeConfig(config, path).pipe(Effect.flatMap((validated) => io(async () => {
-  await mkdir(dirname(path), { recursive: !0 });
-  const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile(temporary, `${JSON.stringify(validated, null, 2)}
-`, { mode: 384 });
-  await rename(temporary, path);
-}, path))), redact = (value) => Array.isArray(value) ? value.map(redact) : value !== null && typeof value === "object" ? Object.fromEntries(Object.entries(value).map(([key, item]) => [key, /secret|password|token|api.?key|credential/i.test(key) ? "[redacted]" : redact(item)])) : value;

package/dist/config.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/plugins.d.ts

@@ -1,6 +0,0 @@
-import { Effect } from "effect";
-import { HarnessError } from "@xandreed/core";
-import type { HarnessConfig, Plugin } from "@xandreed/core";
-export declare const loadPlugins: (config: HarnessConfig, builtins: ReadonlyArray<Plugin>, workspace: string, home: string) => Effect.Effect<ReadonlyArray<Plugin>, HarnessError>;
-/** A plugin's options as one JSON Schema, its definitions inline under `$defs`. */
-export declare const pluginSchema: (plugin: Plugin) => import("effect/JsonSchema").JsonSchema;

package/dist/plugins.js

@@ -1,18 +0,0 @@
-import { createRequire } from "node:module";
-import { join, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-import { Effect, Schema } from "effect";
-import { HarnessError } from "@xandreed/core";
-export const loadPlugins = (config, builtins, workspace, home) => Effect.reduce([...new Set((config.plugins ?? []).filter((entry) => entry.enabled !== !1).map((entry) => entry.use))], () => builtins, (loaded, use) => {
-  if (loaded.some((plugin) => plugin.id === use))
-    return Effect.succeed(loaded);
-  return (use.startsWith(".") || use.startsWith("/") ? Effect.succeed(resolve(workspace, use)) : Effect.try(() => createRequire(join(workspace, "package.json")).resolve(use)).pipe(Effect.catch(() => Effect.try(() => createRequire(join(home, ".efferent/plugins/package.json")).resolve(use))))).pipe(Effect.flatMap((path) => Effect.tryPromise(() => import(pathToFileURL(path).href))), Effect.map((module) => {
-    const value = module.default;
-    if (value === null || typeof value !== "object" || typeof value.build !== "function" || !Array.isArray(value.requires) || !Array.isArray(value.provides) || typeof value.version !== "string")
-      return { valid: !1 };
-    return { valid: !0, plugin: { ...value, id: use } };
-  }), Effect.mapError((error) => new HarnessError({ code: "plugin.load", plugin: use, message: `Cannot load installed plugin ${use}: ${String(error)}` })), Effect.flatMap((result) => result.valid ? Effect.succeed([...loaded, result.plugin]) : Effect.fail(new HarnessError({ code: "plugin.manifest", plugin: use, message: "The module must default-export a definePlugin definition" }))));
-}), pluginSchema = (plugin) => {
-  const document = Schema.toJsonSchemaDocument(plugin.schema);
-  return Object.keys(document.definitions).length > 0 ? { ...document.schema, $defs: document.definitions } : document.schema;
-};