@xandreed/runtime 0.3.0 → 0.8.0-next.0

package/README.md

@@ -1,5 +1,5 @@
 # @xandreed/runtime
 
-Efferent composable agent framework, 0.3.0. Bun on Linux.
+Efferent composable agent framework, 0.8.0-next.0. Bun on Linux.
 
 Documentation: https://github.com/xandreeddev/efferent

package/dist/config.d.ts

@@ -17,67 +17,67 @@ export declare const loadConfig: (options: {
 }) => 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 use: string;
             readonly enabled?: boolean | undefined;
         }[] | undefined;
         bindings?: {
             readonly [x: string]: string;
         } | undefined;
-        system?: string | undefined;
-        version: 1;
         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 use: string;
                     readonly enabled?: boolean | undefined;
                 }[] | undefined;
                 readonly bindings?: {
                     readonly [x: string]: string;
                 } | undefined;
-                readonly system?: 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 use: string;
                 readonly enabled?: boolean | undefined;
             }[] | undefined;
             readonly bindings?: {
                 readonly [x: string]: string;
             } | undefined;
-            readonly system?: string | undefined;
-            readonly version: 1;
             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 use: string;
                         readonly enabled?: boolean | undefined;
                     }[] | undefined;
                     readonly bindings?: {
                         readonly [x: string]: string;
                     } | undefined;
-                    readonly system?: string | undefined;
                 };
             } | undefined;
         };

package/dist/config.js

@@ -17,11 +17,11 @@ export const mergeConfig = (base, overlay) => ({
   plugins: mergeEntries(base.plugins ?? [], overlay.plugins ?? []),
   bindings: { ...base.bindings, ...overlay.bindings },
   profiles: { ...base.profiles, ...overlay.profiles }
-}), decodeConfig = (input, source) => Schema.decodeUnknown(HarnessConfig)(input, { onExcessProperty: "error" }).pipe(Effect.mapError((error) => new HarnessError({ code: "config.invalid", message: `${source}: ${String(error)}` })));
+}), 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.decodeUnknown(Schema.parseJson(HarnessConfig))(text, { onExcessProperty: "error" })), Effect.mapError((error) => new HarnessError({ code: "config.invalid", message: `${path}: ${String(error)}` }))), readBase = (directory) => Effect.gen(function* () {
+}), 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` }));

package/dist/graph.js

@@ -1,7 +1,7 @@
 import { Context, Effect, Schema, Scope } from "effect";
 import { createHash } from "node:crypto";
-import { HarnessError, PLUGIN_API_VERSION } from "@xandreed/core";
-const invalid = (message) => Effect.fail(new HarnessError({ code: "config.graph", message }));
+import { HarnessError, PLUGIN_API_VERSION, SUPPORTED_PLUGIN_API_VERSIONS } from "@xandreed/core";
+const invalid = (message) => Effect.fail(new HarnessError({ code: "config.graph", message })), contributes = (node) => node.plugin.contributes ?? [], optional = (node) => node.plugin.optional ?? [];
 export const resolveGraph = (config, plugins, external = []) => Effect.gen(function* () {
   const duplicatePlugin = plugins.find((plugin, index) => plugins.findIndex((other) => other.id === plugin.id) !== index);
   if (duplicatePlugin !== void 0)
@@ -13,10 +13,10 @@ export const resolveGraph = (config, plugins, external = []) => Effect.gen(funct
     const plugin = plugins.find((candidate) => candidate.id === entry.use);
     if (plugin === void 0)
       return yield* invalid(`plugin ${entry.use} is not installed (instance ${entry.id})`);
-    if (plugin.apiVersion !== PLUGIN_API_VERSION)
+    if (!SUPPORTED_PLUGIN_API_VERSIONS.includes(plugin.apiVersion))
       return yield* invalid(`${entry.id}: plugin API ${plugin.apiVersion} is incompatible with ${PLUGIN_API_VERSION}`);
     const options = { ...plugin.defaults, ...entry.options };
-    yield* Schema.decodeUnknown(plugin.schema)(options, { onExcessProperty: "error" }).pipe(Effect.mapError((error) => new HarnessError({ code: "config.options", plugin: entry.id, message: String(error) })));
+    yield* Schema.decodeUnknownEffect(plugin.schema)(options, { onExcessProperty: "error", reportInput: !0 }).pipe(Effect.mapError((error) => new HarnessError({ code: "config.options", plugin: entry.id, message: String(error) })));
     return { entry, plugin, options };
   })), keys = [...new Set(nodes.flatMap((node) => node.plugin.provides))], providers = Object.fromEntries(yield* Effect.forEach(keys, (key) => Effect.gen(function* () {
     const candidates = nodes.filter((node) => node.plugin.provides.includes(key)), binding = config.bindings?.[key];
@@ -27,29 +27,41 @@ export const resolveGraph = (config, plugins, external = []) => Effect.gen(funct
     return [key, binding ?? candidates[0].entry.id];
   })));
   yield* Effect.forEach(Object.keys(config.bindings ?? {}), (key) => keys.includes(key) ? Effect.void : invalid(`binding references an unavailable service: ${key}`));
-  yield* Effect.forEach(nodes, (node) => Effect.forEach(node.plugin.requires, (key) => {
-    const provider = nodes.find((candidate) => candidate.entry.id === providers[key]);
-    if (provider === void 0 && !external.includes(key))
+  const contributors = (key, except) => nodes.filter((node) => node !== except && contributes(node).includes(key)), contributed = new Set(nodes.flatMap(contributes));
+  yield* Effect.forEach(nodes, (node) => Effect.forEach([...node.plugin.requires, ...optional(node)], (key) => {
+    const provider = nodes.find((candidate) => candidate.entry.id === providers[key]), isCapability = contributed.has(key);
+    if (provider !== void 0 && isCapability)
+      return invalid(`${key} is both provided and contributed`);
+    if (provider === void 0 && !isCapability && !external.includes(key) && node.plugin.requires.includes(key))
       return invalid(`${node.entry.id} requires missing service ${key}`);
-    if (node.plugin.scope === "runtime" && provider?.plugin.scope === "session")
+    const sources = isCapability ? contributors(key, node) : provider === void 0 ? [] : [provider];
+    if (node.plugin.scope === "runtime" && sources.some((source) => source.plugin.scope === "session"))
       return invalid(`${node.entry.id}: runtime plugins cannot depend on session service ${key}`);
     return Effect.void;
   }));
   const order = (remaining, sorted) => {
     if (remaining.length === 0)
       return Effect.succeed(sorted);
-    const ready = remaining.filter((node) => node.plugin.requires.every((key) => external.includes(key) || sorted.some((candidate) => candidate.entry.id === providers[key])));
+    const ready = remaining.filter((node) => [...node.plugin.requires, ...optional(node)].every((key) => external.includes(key) || (contributed.has(key) ? contributors(key, node).every((source) => sorted.includes(source)) : providers[key] === void 0 ? !node.plugin.requires.includes(key) : sorted.some((candidate) => candidate.entry.id === providers[key]))));
     if (ready.length === 0)
       return invalid(`dependency cycle: ${remaining.map((node) => node.entry.id).join(" \u2192 ")}`);
     return Effect.suspend(() => order(remaining.filter((node) => !ready.includes(node)), [...sorted, ...ready]));
   };
   return { nodes: yield* order(nodes, []), providers, config };
-}), activateGraph = (graph, lifetime, services, scope) => Effect.reduce(graph.nodes.filter((node) => node.plugin.scope === lifetime), services, (context, node) => Effect.gen(function* () {
-  const dependencies = Context.unsafeMake(new Map(node.plugin.requires.flatMap((key) => context.unsafeMap.has(key) ? [[key, context.unsafeMap.get(key)]] : []))), built = yield* Scope.extend(node.plugin.build(node.options, dependencies), scope), missing = node.plugin.provides.filter((key) => !built.unsafeMap.has(key));
+});
+const contributedKeys = (graph) => new Set(graph.nodes.flatMap(contributes)), asArray = (value) => Array.isArray(value) ? value : [];
+export const activateGraph = (graph, lifetime, services, scope) => Effect.reduce(graph.nodes.filter((node) => node.plugin.scope === lifetime), () => services, (context, node) => Effect.gen(function* () {
+  const dependencies = Context.makeUnsafe(new Map([...node.plugin.requires, ...optional(node)].flatMap((key) => context.mapUnsafe.has(key) ? [[key, context.mapUnsafe.get(key)]] : contributedKeys(graph).has(key) ? [[key, []]] : []))), built = yield* Scope.provide(node.plugin.build(node.options, dependencies), scope), missing = [...node.plugin.provides, ...contributes(node)].filter((key) => !built.mapUnsafe.has(key));
   if (missing.length > 0)
     return yield* invalid(`${node.entry.id} did not provide declared services: ${missing.join(", ")}`);
-  const selected = new Map(node.plugin.provides.flatMap((key) => graph.providers[key] === node.entry.id ? [[key, built.unsafeMap.get(key)]] : []));
-  return Context.merge(context, Context.unsafeMake(selected));
+  const invalidCapability = contributes(node).find((key) => !Array.isArray(built.mapUnsafe.get(key)));
+  if (invalidCapability !== void 0)
+    return yield* invalid(`${node.entry.id} contributed a non-array value to ${invalidCapability}`);
+  const selected = new Map([
+    ...node.plugin.provides.flatMap((key) => graph.providers[key] === node.entry.id ? [[key, built.mapUnsafe.get(key)]] : []),
+    ...contributes(node).map((key) => [key, [...asArray(context.mapUnsafe.get(key)), ...asArray(built.mapUnsafe.get(key))]])
+  ]);
+  return Context.merge(context, Context.makeUnsafe(selected));
 })), graphFingerprint = (graph, scope) => createHash("sha256").update(JSON.stringify({
   nodes: graph.nodes.filter((node) => scope === void 0 || node.plugin.scope === scope).map((node) => ({
     id: node.entry.id,

package/dist/live-layer.adapter.js

@@ -1,9 +1,9 @@
-import { Context, Effect, Exit, Ref, Scope } from "effect";
+import { Context, Effect, Exit, Ref, Scope, Semaphore } from "effect";
 import * as Layers from "effect/Layer";
 import { HarnessError } from "@xandreed/core";
 export const makeLiveLayer = (initial) => Effect.gen(function* () {
-  const dependencies = yield* Effect.context(), gate = yield* Effect.makeSemaphore(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(), services = yield* restore(Layers.buildWithScope(layer, scope).pipe(Effect.provide(dependencies))).pipe(Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(scope, exit) : Effect.void));
+  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 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);
   yield* Ref.set(generations, new Map([[0, first]]));

package/dist/plugins.d.ts

@@ -1,5 +1,6 @@
-import { Effect, JSONSchema } from "effect";
+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>;
-export declare const pluginSchema: (plugin: Plugin) => JSONSchema.JsonSchema7Root;
+/** 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,15 +1,18 @@
 import { createRequire } from "node:module";
 import { join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-import { Effect, JSONSchema } from "effect";
+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) => {
+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.orElse(() => Effect.try(() => createRequire(join(home, ".efferent/plugins/package.json")).resolve(use))))).pipe(Effect.flatMap((path) => Effect.tryPromise(() => import(pathToFileURL(path).href))), Effect.map((module) => {
+  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) => JSONSchema.make(plugin.schema);
+}), pluginSchema = (plugin) => {
+  const document = Schema.toJsonSchemaDocument(plugin.schema);
+  return Object.keys(document.definitions).length > 0 ? { ...document.schema, $defs: document.definitions } : document.schema;
+};

package/dist/testing/version.port.d.ts

@@ -1,5 +1,5 @@
 import { Context } from "effect";
-declare const Version_base: Context.TagClass<Version, "test/Version", {
+declare const Version_base: Context.ServiceClass<Version, "test/Version", {
     readonly value: number;
 }>;
 export declare class Version extends Version_base {

package/dist/testing/version.port.js

@@ -1,4 +1,4 @@
 import { Context } from "effect";
 
-export class Version extends Context.Tag("test/Version")() {
+export class Version extends Context.Service()("test/Version") {
 }

package/dist/testing.port.d.ts

@@ -1,8 +1,11 @@
 import { Context } from "effect";
-declare const Value_base: Context.TagClass<Value, "test/Value", number>;
+declare const Value_base: Context.ServiceClass<Value, "test/Value", number>;
 export declare class Value extends Value_base {
 }
-declare const Consumer_base: Context.TagClass<Consumer, "test/Consumer", number>;
+declare const Consumer_base: Context.ServiceClass<Consumer, "test/Consumer", number>;
 export declare class Consumer extends Consumer_base {
 }
+declare const Items_base: Context.ServiceClass<Items, "test/Items", readonly string[]>;
+export declare class Items extends Items_base {
+}
 export {};

package/dist/testing.port.js

@@ -1,7 +1,10 @@
 import { Context } from "effect";
 
-export class Value extends Context.Tag("test/Value")() {
+export class Value extends Context.Service()("test/Value") {
 }
 
-export class Consumer extends Context.Tag("test/Consumer")() {
+export class Consumer extends Context.Service()("test/Consumer") {
+}
+
+export class Items extends Context.Service()("test/Items") {
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xandreed/runtime",
-  "version": "0.3.0",
+  "version": "0.8.0-next.0",
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
@@ -10,8 +10,8 @@
     }
   },
   "dependencies": {
-    "@xandreed/core": "0.3.0",
-    "effect": "3.21.4"
+    "@xandreed/core": "0.8.0-next.0",
+    "effect": "4.0.0-rc.118"
   },
   "private": false,
   "types": "./dist/index.d.ts",