@xandreed/runtime 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Xand Reed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

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

package/dist/config.d.ts

@@ -0,0 +1,88 @@
+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;
+        plugins?: readonly {
+            readonly id: 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 plugins?: readonly {
+                    readonly id: 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 plugins?: readonly {
+                readonly id: 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 plugins?: readonly {
+                        readonly id: 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;
+        };
+    }[];
+    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

@@ -0,0 +1,50 @@
+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.decodeUnknown(HarnessConfig)(input, { onExcessProperty: "error" }).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* () {
+  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

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

package/dist/graph.d.ts

@@ -0,0 +1,17 @@
+import { Context, Effect, Scope } from "effect";
+import { HarnessError } from "@xandreed/core";
+import type { HarnessConfig, Plugin, PluginEntry } from "@xandreed/core";
+export interface PluginNode {
+    readonly entry: PluginEntry;
+    readonly plugin: Plugin;
+    readonly options: Readonly<Record<string, unknown>>;
+}
+export interface PluginGraph {
+    readonly nodes: ReadonlyArray<PluginNode>;
+    readonly providers: Readonly<Record<string, string>>;
+    readonly config: HarnessConfig;
+}
+export declare const resolveGraph: (config: HarnessConfig, plugins: ReadonlyArray<Plugin>, external?: ReadonlyArray<string>) => Effect.Effect<PluginGraph, HarnessError>;
+/** Every activation is scoped. A failed staging scope is disposed by its caller. */
+export declare const activateGraph: (graph: PluginGraph, lifetime: "runtime" | "session", services: Context.Context<never>, scope: Scope.Scope) => Effect.Effect<Context.Context<never>, HarnessError>;
+export declare const graphFingerprint: (graph: PluginGraph, scope?: "runtime" | "session") => string;

package/dist/graph.js

@@ -0,0 +1,62 @@
+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 }));
+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)
+    return yield* invalid(`duplicate plugin definition: ${duplicatePlugin.id}`);
+  const entries = (config.plugins ?? []).filter((entry) => entry.enabled !== !1), duplicate = entries.find((entry, index) => entries.findIndex((other) => other.id === entry.id) !== index);
+  if (duplicate !== void 0)
+    return yield* invalid(`duplicate plugin instance: ${duplicate.id}`);
+  const nodes = yield* Effect.forEach(entries, (entry) => Effect.gen(function* () {
+    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)
+      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) })));
+    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];
+    if (binding !== void 0 && !candidates.some((node) => node.entry.id === binding))
+      return yield* invalid(`${key}: binding ${binding} does not provide this service`);
+    if (candidates.length > 1 && binding === void 0)
+      return yield* invalid(`${key}: choose a binding from ${candidates.map((node) => node.entry.id).join(", ")}`);
+    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))
+      return invalid(`${node.entry.id} requires missing service ${key}`);
+    if (node.plugin.scope === "runtime" && provider?.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])));
+    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));
+  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));
+})), 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,
+    use: node.plugin.id,
+    version: node.plugin.version,
+    options: node.options
+  })),
+  bindings: Object.fromEntries(Object.entries(graph.providers).filter(([, id]) => scope === void 0 || graph.nodes.some((node) => node.entry.id === id && node.plugin.scope === scope))),
+  ...scope === "runtime" ? {} : { system: graph.config.system }
+})).digest("hex");

package/dist/graph.test.d.ts

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

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/live-layer.adapter.d.ts

@@ -0,0 +1,11 @@
+import { Effect, Scope } from "effect";
+import type { Layer } from "effect";
+import { HarnessError } from "@xandreed/core";
+/** Scoped generations for replaceable modules. Each use pins one successful
+ * generation; retiring a generation does not close its resources until its
+ * last user completes. Failed staging never replaces the working services. */
+export declare const makeLiveLayer: <A, E, R>(initial: Layer.Layer<A, E, R>) => Effect.Effect<{
+    use: <B, E2, R2>(effect: Effect.Effect<B, E2, R2>) => Effect.Effect<B, HarnessError | E2, Exclude<R2, A>>;
+    generation: Effect.Effect<number, never, never>;
+    replace: (layer: Layer.Layer<A, E, R>) => Effect.Effect<number, HarnessError | E, Exclude<R, R>>;
+}, E, Scope.Scope | R>;

package/dist/live-layer.adapter.js

@@ -0,0 +1,48 @@
+import { Context, Effect, Exit, Ref, Scope } 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));
+    return { id, services, scope, leases: 0, retired: !1 };
+  })), first = yield* stage(initial, 0);
+  yield* Ref.set(generations, new Map([[0, first]]));
+  yield* Effect.addFinalizer(() => gate.withPermits(1)(Effect.gen(function* () {
+    yield* Ref.set(closed, !0);
+    const remaining = yield* Ref.getAndSet(generations, new Map);
+    yield* Effect.forEach(remaining.values(), (generation) => Scope.close(generation.scope, Exit.void));
+  })));
+  const acquire = gate.withPermits(1)(Effect.gen(function* () {
+    if (yield* Ref.get(closed))
+      return yield* Effect.fail(unavailable());
+    const id = yield* Ref.get(current), all = yield* Ref.get(generations), generation = all.get(id);
+    if (!generation)
+      return yield* Effect.fail(unavailable());
+    yield* Ref.set(generations, new Map([...all, [id, { ...generation, leases: generation.leases + 1 }]]));
+    return generation;
+  })), release = (lease) => gate.withPermits(1)(Effect.gen(function* () {
+    const all = yield* Ref.get(generations), generation = all.get(lease.id);
+    if (!generation)
+      return;
+    const next = { ...generation, leases: generation.leases - 1 };
+    if (next.retired && next.leases === 0) {
+      yield* Ref.set(generations, new Map([...all].filter(([id]) => id !== next.id)));
+      yield* Scope.close(next.scope, Exit.void);
+    } else
+      yield* Ref.set(generations, new Map([...all, [next.id, next]]));
+  }));
+  return {
+    use: (effect) => Effect.acquireUseRelease(acquire, (generation) => effect.pipe(Effect.provide(generation.services)), release),
+    generation: Ref.get(current),
+    replace: (layer) => gate.withPermits(1)(Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      if (yield* Ref.get(closed))
+        return yield* Effect.fail(unavailable());
+      const id = yield* Ref.get(current), next = yield* restore(stage(layer, id + 1)), all = yield* Ref.get(generations), previous = all.get(id), retained = [...all].filter(([key]) => key !== id);
+      yield* Ref.set(generations, new Map([...retained, ...previous && previous.leases > 0 ? [[id, { ...previous, retired: !0 }]] : [], [next.id, next]]));
+      yield* Ref.set(current, next.id);
+      if (previous && previous.leases === 0)
+        yield* Scope.close(previous.scope, Exit.void);
+      return next.id;
+    })))
+  };
+});

package/dist/live-layer.test.d.ts

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

package/dist/plugins.d.ts

@@ -0,0 +1,5 @@
+import { Effect, JSONSchema } 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;

package/dist/plugins.js

@@ -0,0 +1,15 @@
+import { createRequire } from "node:module";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { Effect, JSONSchema } 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.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) => {
+    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);

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

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

package/dist/testing/version.port.js

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

package/dist/testing.port.d.ts

@@ -0,0 +1,8 @@
+import { Context } from "effect";
+declare const Value_base: Context.TagClass<Value, "test/Value", number>;
+export declare class Value extends Value_base {
+}
+declare const Consumer_base: Context.TagClass<Consumer, "test/Consumer", number>;
+export declare class Consumer extends Consumer_base {
+}
+export {};

package/dist/testing.port.js

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

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@xandreed/runtime",
+  "version": "0.3.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@xandreed/core": "0.3.0",
+    "effect": "3.21.4"
+  },
+  "private": false,
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "skills",
+    "profiles",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "license": "MIT"
+}