@fnioc/di 1.0.0

package/dist/scope.js

@@ -0,0 +1,466 @@
+// The scope chain + the resolution engine — the correctness core of the engine.
+//
+// A Scope is a node in a parent-linked chain. It owns and caches the instances
+// whose lifetime tag matches its name, may hold local override registrations
+// that shadow ancestors, and disposes the instances it owns in reverse
+// construction order when closed.
+//
+// Resolution (§"The critical correctness rule"): on a cache miss the instance
+// is constructed by resolving ITS constructor dependencies relative to the
+// OWNING scope (the matched ancestor), never the scope that triggered the
+// resolve. That is what makes a long-lived service depending on a shorter-lived
+// one fail loudly instead of silently capturing it.
+import { getDeps } from "@fnioc/core";
+import { AsyncDisposalRequiredError, CircularDependencyError, FactoryTargetError, MissingMetadataError, MissingScopeError, NoSatisfiableSignatureError, UnregisteredTokenError, } from "./errors.js";
+/** True when a value implements the native synchronous `Disposable`. */
+function isDisposable(value) {
+    return (value != null &&
+        (typeof value === "object" || typeof value === "function") &&
+        typeof value[Symbol.dispose] ===
+            "function");
+}
+/** True when a value implements the native `AsyncDisposable`. */
+function isAsyncDisposable(value) {
+    return (value != null &&
+        (typeof value === "object" || typeof value === "function") &&
+        typeof value[Symbol.asyncDispose] === "function");
+}
+/** True when a value is thenable (a Promise or Promise-like). */
+function isThenable(value) {
+    return (value != null &&
+        (typeof value === "object" || typeof value === "function") &&
+        typeof value.then === "function");
+}
+/**
+ * True when a `DepSlot` is a `FactoryRef` — a factory-injected parameter. A
+ * slot is a string token, the `null` hole sentinel, or this object form.
+ */
+function isFactoryRef(slot) {
+    return (slot !== null &&
+        typeof slot === "object" &&
+        typeof slot.factory === "string");
+}
+/**
+ * A node in the scope chain. Created from a `DiBuilder` (the root) or from a
+ * parent scope (`.createScope`). Holds the instances it owns and any local
+ * override registrations.
+ *
+ * The generic `Scopes` is the user's scope-name union, threaded so
+ * `.createScope` only accepts declared names.
+ */
+export class Scope {
+    name;
+    parent;
+    baseRegistrations;
+    /** Local override registrations held at this scope (shadow ancestors). */
+    localRegistrations = new Map();
+    /** Instances this scope owns and caches, keyed by token. */
+    instances = new Map();
+    /** Owned instances in construction order — disposed in reverse. */
+    ownedOrder = [];
+    disposed = false;
+    constructor(
+    /** This scope's tag name. The root scope's name is its lifetime. */
+    name, 
+    /** The parent scope, or `undefined` for the root. */
+    parent, 
+    /** The builder's base registration map (shared, walked last). */
+    baseRegistrations) {
+        this.name = name;
+        this.parent = parent;
+        this.baseRegistrations = baseRegistrations;
+    }
+    /** Creates a parent-linked child scope with the given (declared) name. */
+    createScope(childName) {
+        return new Scope(childName, this, this.baseRegistrations);
+    }
+    /**
+     * Registers a scope-local override. Shadows any ancestor or base registration
+     * for the same token, for this scope and its descendants only. The override
+     * paths (`useFactory` / `useValue`) are also available here so a single scope
+     * (e.g. a test scope) can swap an implementation without rebuilding the
+     * builder.
+     */
+    registerFactory(token, useFactory, tag) {
+        this.localRegistrations.set(token, {
+            kind: "factory",
+            useFactory: useFactory,
+            tag,
+        });
+        return this;
+    }
+    /** Registers a scope-local `useValue` override (see `registerFactory`). */
+    registerValue(token, useValue) {
+        this.localRegistrations.set(token, { kind: "value", useValue });
+        return this;
+    }
+    /**
+     * Resolves a token to an instance, walking the parent chain for both the
+     * registration and the owning scope. The public entry point starts a fresh
+     * cycle-detection stack.
+     */
+    resolve(token) {
+        return this.resolveWith(token, []);
+    }
+    // ── Registration lookup ─────────────────────────────────────────────────────
+    /**
+     * Walks UP the chain (this scope's locals → ancestors' locals → base map),
+     * returning the nearest registration for `token`. Child shadows parent.
+     */
+    lookup(token) {
+        // Aliasing `this` to walk the parent chain iteratively.
+        let node = this;
+        while (node !== undefined) {
+            const local = node.localRegistrations.get(token);
+            if (local !== undefined)
+                return local;
+            node = node.parent;
+        }
+        return this.baseRegistrations.get(token);
+    }
+    /**
+     * Finds the nearest ancestor scope (inclusive of this one) whose name matches
+     * `tag`, walking UP the chain. Returns `undefined` when none matches.
+     */
+    findOwner(tag) {
+        // Aliasing `this` to walk the parent chain iteratively.
+        let node = this;
+        while (node !== undefined) {
+            if (node.name === tag)
+                return node;
+            node = node.parent;
+        }
+        return undefined;
+    }
+    /** The chain of scope names from this scope up to the root, for diagnostics. */
+    chainNames() {
+        const names = [];
+        // Aliasing `this` to walk the parent chain iteratively.
+        let node = this;
+        while (node !== undefined) {
+            names.push(node.name);
+            node = node.parent;
+        }
+        return names;
+    }
+    // ── Resolution ──────────────────────────────────────────────────────────────
+    /**
+     * The internal resolver. `stack` is the active resolution path (for cycle
+     * detection); it is shared across the whole `resolve()` call but never across
+     * separate calls.
+     */
+    resolveWith(token, stack) {
+        if (stack.includes(token)) {
+            throw new CircularDependencyError([...stack, token]);
+        }
+        const registration = this.lookup(token);
+        if (registration === undefined) {
+            throw new UnregisteredTokenError(token);
+        }
+        // useValue: the instance already exists; ownership/caching is moot.
+        if (registration.kind === "value") {
+            return registration.useValue;
+        }
+        // Transient (no tag): never cached. Build relative to THIS scope and return
+        // a fresh instance every time.
+        if (registration.tag === undefined) {
+            stack.push(token);
+            try {
+                return this.instantiate(token, registration, this, stack);
+            }
+            finally {
+                stack.pop();
+            }
+        }
+        // Tagged: find the owning ancestor scope. No match ⇒ throw (never
+        // auto-create — that is the captive-dependency detector).
+        const owner = this.findOwner(registration.tag);
+        if (owner === undefined) {
+            throw new MissingScopeError(token, registration.tag, this.chainNames());
+        }
+        // Cache hit on the owner ⇒ return the cached instance (or Promise).
+        if (owner.instances.has(token)) {
+            return owner.instances.get(token);
+        }
+        // Cache miss ⇒ construct relative to the OWNER, cache on the owner.
+        stack.push(token);
+        try {
+            const instance = owner.instantiate(token, registration, owner, stack);
+            owner.instances.set(token, instance);
+            owner.ownedOrder.push(instance);
+            return instance;
+        }
+        finally {
+            stack.pop();
+        }
+    }
+    /**
+     * Builds an instance for `registration`. `owningScope` is the scope whose
+     * chain the dependencies are resolved against — THE critical rule. For a
+     * factory override that is the scope passed to the closure; for a class it is
+     * the scope its ctor deps resolve relative to.
+     */
+    instantiate(token, registration, owningScope, stack) {
+        if (registration.kind === "factory") {
+            // The factory resolves its own deps relative to the owning scope, but the
+            // closure only sees a `resolve` that continues the active cycle stack.
+            const scopeView = {
+                resolve: (depToken) => owningScope.resolveWith(depToken, stack),
+            };
+            return registration.useFactory(scopeView);
+        }
+        return owningScope.construct(token, registration.ctor, stack);
+    }
+    /**
+     * Constructs a class instance on a DIRECT resolve, resolving its constructor
+     * dependencies relative to THIS scope (the owning scope). Performs greedy
+     * signature selection over the ctor's DepRecord, then fills each slot:
+     *
+     *   - a string token → resolved through this scope's chain (selection
+     *     guarantees every string-token slot here is resolvable);
+     *   - a `FactoryRef` → injected as a callable (see `makeFactory`);
+     *   - a `null` hole → there is no caller on a direct resolve, so it lands as
+     *     `undefined`. Holes are meaningfully filled only when the class is a
+     *     factory target — see `constructPartitioned`.
+     */
+    construct(token, ctor, stack) {
+        const record = getDeps(ctor);
+        // No metadata: a zero-arg ctor is `new`ed directly; a ctor with parameters
+        // and no record is a hard error with actionable guidance.
+        if (record === undefined || record.signatures.length === 0) {
+            if (ctor.length > 0) {
+                throw new MissingMetadataError(token, ctor.name);
+            }
+            return new ctor();
+        }
+        const signature = this.selectSignature(token, ctor, record.signatures);
+        const args = signature.map((slot) => {
+            if (isFactoryRef(slot)) {
+                // A factory-injected parameter: a callable that builds `slot.factory`'s
+                // target on demand, resolving the target's own deps relative to THIS
+                // scope (the owner) so §5.4 still holds at call time.
+                return this.makeFactory(slot);
+            }
+            if (slot === null) {
+                // A hole with no caller on a direct resolve ⇒ unfilled (`undefined`).
+                return undefined;
+            }
+            // A string token — resolve it through this scope's chain.
+            return this.resolveWith(slot, stack);
+        });
+        return new ctor(...args);
+    }
+    /**
+     * Builds the callable injected for a `FactoryRef` parameter.
+     *
+     * The target ctor's signature is partitioned at CALL time against the live
+     * registration map: each slot that is a registered token is resolved; each
+     * slot that is an unregistered token or a `null` hole takes the next
+     * caller-supplied argument, positionally. The injected callable therefore
+     * exposes only the target's unregistered parameters, in their relative order
+     * — no Ramda-style placeholders, no leaked constructor arity.
+     *
+     * Lifetime semantics:
+     *   - A ZERO-ARG factory (the target ctor has no holes / unregistered params)
+     *     routes the build through the normal `resolve` path, so it RESPECTS the
+     *     target's registered lifetime: a singleton target yields the same
+     *     instance on every call; a transient target yields a fresh one.
+     *   - A PARAMETERIZED factory (the target has holes / unregistered params
+     *     filled per call) constructs a FRESH instance on every call and BYPASSES
+     *     the instance cache. Caller args differ per call, so caching would be
+     *     wrong — two calls with different arguments must not collapse to one
+     *     cached instance.
+     *
+     * The closure captures `this` as the owning scope. §5.4 holds at call time:
+     * the target's deps resolve relative to the scope that owns the
+     * factory-holding instance, exactly as a direct resolve would — so a factory
+     * captured by a singleton that tries to build a request-scoped target still
+     * throws `MissingScopeError` when invoked.
+     */
+    makeFactory(ref) {
+        const owningScope = this;
+        const target = this.lookup(ref.factory);
+        if (target === undefined) {
+            throw new FactoryTargetError(ref.factory, "unregistered");
+        }
+        // A factory builds its target with `new` — the target must be a class
+        // registration, not a useValue/useFactory override.
+        if (target.kind !== "class") {
+            throw new FactoryTargetError(ref.factory, "not-a-class");
+        }
+        const targetCtor = target.ctor;
+        const record = getDeps(targetCtor);
+        const targetSignature = record === undefined || record.signatures.length === 0
+            ? undefined
+            : owningScope.selectTargetSignature(record.signatures);
+        // A target slot is caller-supplied when it is a hole or a string token NOT
+        // in the live registration map (a nested FactoryRef is itself injected, not
+        // caller-supplied). If the target has any such slot the factory is
+        // parameterized; otherwise it is a bare zero-arg factory.
+        const parameterized = targetSignature !== undefined &&
+            targetSignature.some((slot) => slot === null || (!isFactoryRef(slot) && !owningScope.isResolvable(slot)));
+        if (!parameterized) {
+            return () => owningScope.resolveWith(ref.factory, []);
+        }
+        // Parameterized factory: construct a fresh instance each call, partitioning
+        // the target signature against the live registration map and threading the
+        // caller args into the holes / unregistered slots. A fresh cycle stack per
+        // call — the factory runs outside the resolve that created it.
+        return (...callArgs) => owningScope.constructPartitioned(ref.factory, targetCtor, targetSignature, callArgs);
+    }
+    /**
+     * Constructs a factory target, partitioning its already-selected signature
+     * against the live registration map: a registered token is resolved; an
+     * unregistered token or a `null` hole takes the next caller-supplied argument
+     * positionally. Always a fresh instance — a parameterized factory bypasses
+     * the instance cache (caller args differ per call). Runs on a fresh cycle
+     * stack since the factory is invoked outside the original resolve.
+     */
+    constructPartitioned(token, ctor, signature, callerArgs) {
+        const stack = [];
+        let nextCallerArg = 0;
+        const args = signature.map((slot) => {
+            if (isFactoryRef(slot)) {
+                return this.makeFactory(slot);
+            }
+            // An unregistered token or a hole is caller-supplied: take the next arg.
+            if (slot === null || !this.isResolvable(slot)) {
+                return callerArgs[nextCallerArg++];
+            }
+            return this.resolveWith(slot, stack);
+        });
+        return new ctor(...args);
+    }
+    /**
+     * Greedy signature selection. Scans signatures longest → shortest and returns
+     * the first SATISFIABLE one. A slot is satisfiable when it is:
+     *
+     *   - a `null` hole — always satisfiable; filled by a caller arg (a direct
+     *     resolve supplies nothing, so it lands as `undefined`);
+     *   - a `FactoryRef` — always satisfiable; injected as a callable. The
+     *     factory's target need not be resolvable for the slot to count (an
+     *     unregistered target surfaces a `FactoryTargetError` when the factory is
+     *     built / called, not here); or
+     *   - a string token whose registration is resolvable in this (the owning)
+     *     scope's chain.
+     *
+     * Only string tokens can be UNsatisfiable. A signature is satisfiable iff
+     * every string-token slot is resolvable.
+     *
+     * - Equal-arity ties break by registration order (the order signatures appear
+     *   in the DepRecord), which `sort`'s stability preserves.
+     * - None satisfiable ⇒ throw naming the unsatisfiable tokens.
+     */
+    selectSignature(token, ctor, signatures) {
+        // Stable sort by descending length; index keeps equal-arity ties in
+        // registration order.
+        const ordered = signatures
+            .map((sig, index) => ({ sig, index }))
+            .sort((a, b) => b.sig.length !== a.sig.length
+            ? b.sig.length - a.sig.length
+            : a.index - b.index);
+        const unsatisfiable = new Set();
+        for (const { sig } of ordered) {
+            let satisfiable = true;
+            for (const slot of sig) {
+                // A hole or a FactoryRef is always satisfiable — only an unresolvable
+                // string token blocks a signature.
+                if (slot === null || isFactoryRef(slot))
+                    continue;
+                if (!this.isResolvable(slot)) {
+                    satisfiable = false;
+                    unsatisfiable.add(slot);
+                }
+            }
+            if (satisfiable)
+                return sig;
+        }
+        throw new NoSatisfiableSignatureError(token, ctor.name, [...unsatisfiable]);
+    }
+    /**
+     * Greedy signature selection for a FACTORY TARGET. Unlike `selectSignature`,
+     * there is no resolvability gate: a target's unregistered tokens are not
+     * unsatisfiable — they are the factory's caller-supplied parameters. So the
+     * choice is purely the longest signature, equal-arity ties broken by
+     * registration order (`sort` stability). Always returns a signature (the
+     * caller has already checked `signatures.length > 0`).
+     */
+    selectTargetSignature(signatures) {
+        return signatures
+            .map((sig, index) => ({ sig, index }))
+            .sort((a, b) => b.sig.length !== a.sig.length
+            ? b.sig.length - a.sig.length
+            : a.index - b.index)[0].sig;
+    }
+    /** True when `token` has a registration somewhere in this scope's chain. */
+    isResolvable(token) {
+        return this.lookup(token) !== undefined;
+    }
+    // ── Disposal ────────────────────────────────────────────────────────────────
+    /**
+     * Closes this scope synchronously, disposing the instances it owns in REVERSE
+     * construction order. Only native `Disposable` instances are disposed.
+     *
+     * Throws `AsyncDisposalRequiredError` if any owned instance is a Promise
+     * (thenable) — a pending Promise cannot be disposed synchronously; the caller
+     * must use `disposeAsync()`. Idempotent: a second call is a no-op.
+     */
+    dispose() {
+        if (this.disposed)
+            return;
+        for (const instance of this.ownedOrder) {
+            if (isThenable(instance)) {
+                throw new AsyncDisposalRequiredError();
+            }
+        }
+        this.disposed = true;
+        for (let i = this.ownedOrder.length - 1; i >= 0; i--) {
+            const instance = this.ownedOrder[i];
+            if (isDisposable(instance)) {
+                instance[Symbol.dispose]();
+            }
+        }
+        this.clear();
+    }
+    /**
+     * Closes this scope asynchronously. Awaits each owned Promise-valued instance
+     * first (so an async factory's result settles before teardown), then disposes
+     * owned instances in REVERSE construction order — honoring both
+     * `Symbol.asyncDispose` and `Symbol.dispose`. Idempotent.
+     */
+    async disposeAsync() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        // Resolve any Promise-valued instances to their settled values so the
+        // disposer sees the real object, not the wrapper.
+        const settled = [];
+        for (const instance of this.ownedOrder) {
+            settled.push(isThenable(instance) ? await instance : instance);
+        }
+        for (let i = settled.length - 1; i >= 0; i--) {
+            const instance = settled[i];
+            if (isAsyncDisposable(instance)) {
+                await instance[Symbol.asyncDispose]();
+            }
+            else if (isDisposable(instance)) {
+                instance[Symbol.dispose]();
+            }
+        }
+        this.clear();
+    }
+    /** Drops owned references after disposal so they can be collected. */
+    clear() {
+        this.instances.clear();
+        this.ownedOrder.length = 0;
+    }
+    /** Native `using` support — delegates to `dispose()`. */
+    [Symbol.dispose]() {
+        this.dispose();
+    }
+    /** Native `await using` support — delegates to `disposeAsync()`. */
+    [Symbol.asyncDispose]() {
+        return this.disposeAsync();
+    }
+}
+//# sourceMappingURL=scope.js.map

package/dist/scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.js","sourceRoot":"","sources":["../src/scope.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+import type { Token } from "@fnioc/core";
+/**
+ * A concrete, instantiable constructor producing `I`.
+ *
+ * Deliberately plain `new (...) => I`, NOT `abstract new (...) => I`: the
+ * container instantiates the concrete type, and an `abstract` class cannot be
+ * `new`ed. Passing an abstract class to `.add()` is therefore a type error —
+ * exactly the desired rejection.
+ */
+export type Ctor<I = unknown> = new (...args: never[]) => I;
+/**
+ * A factory override: a closure that builds the instance, given the scope it is
+ * being resolved into (so the factory can `scope.resolve(...)` its own deps).
+ *
+ * May be async — it can return a `Promise<T>`. The container never awaits; the
+ * Promise flows through the sync resolution channel as a value (§"Async as
+ * values"). A consumer that depends on it declares `Promise<T>` and awaits.
+ */
+export type Factory<T = unknown> = (scope: ResolveScope) => T;
+/** A class registration: a token bound to a concrete constructor. */
+export interface ClassRegistration {
+    readonly kind: "class";
+    readonly ctor: Ctor;
+    /**
+     * The lifetime tag — the scope name that owns and caches the instance.
+     * `undefined` means transient (never cached; a fresh instance per resolve).
+     */
+    readonly tag: string | undefined;
+}
+/** A `useFactory` override registration. */
+export interface FactoryRegistration {
+    readonly kind: "factory";
+    readonly useFactory: Factory;
+    readonly tag: string | undefined;
+}
+/** A `useValue` override registration — an already-built instance. */
+export interface ValueRegistration {
+    readonly kind: "value";
+    readonly useValue: unknown;
+}
+/** Any registration the engine can resolve. */
+export type Registration = ClassRegistration | FactoryRegistration | ValueRegistration;
+/**
+ * The resolution surface a factory closure receives. A structural subset of
+ * `Scope` exposing only what an override needs — resolving further tokens.
+ */
+export interface ResolveScope {
+    resolve<T>(token: Token): T;
+}
+/** The override spec accepted by `.register(token, spec)`. */
+export type OverrideSpec<T> = {
+    readonly useFactory: (scope: ResolveScope) => T;
+    readonly tag?: string;
+} | {
+    readonly useValue: T;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC;;;;;;;GAOG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,GAAG,OAAO,IAAI,KAAK,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AAE5D;;;;;;;GAOG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,GAAG,OAAO,IAAI,CAAC,KAAK,EAAE,YAAY,KAAK,CAAC,CAAC;AAE9D,qEAAqE;AACrE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC;AAED,4CAA4C;AAC5C,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC;AAED,sEAAsE;AACtE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED,+CAA+C;AAC/C,MAAM,MAAM,YAAY,GACpB,iBAAiB,GACjB,mBAAmB,GACnB,iBAAiB,CAAC;AAEtB;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,CAAC,CAAC;CAC7B;AAED,8DAA8D;AAC9D,MAAM,MAAM,YAAY,CAAC,CAAC,IACtB;IAAE,QAAQ,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,CAAC,CAAC;IAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1E;IAAE,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAA;CAAE,CAAC"}

package/dist/types.js

@@ -0,0 +1,4 @@
+// Shared runtime types for the engine: the concrete-constructor shape, the
+// registration kinds, and the resolver-facing scope contract.
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,8DAA8D"}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@fnioc/di",
+  "version": "1.0.0",
+  "description": "The ioc runtime engine: DiBuilder, scopes, resolution, captive-dependency protection, factories, and native disposal.",
+  "keywords": [
+    "dependency-injection",
+    "di",
+    "ioc",
+    "typescript",
+    "scope",
+    "container"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fnioc/ioc.git",
+    "directory": "packages/di"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "test": "bun test",
+    "lint": "echo 'lint: typecheck runs in build (tsc -b)' && exit 0"
+  },
+  "peerDependencies": {
+    "@fnioc/core": "^1.0.0"
+  },
+  "devDependencies": {
+    "@fnioc/core": "^1.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}