@zhin.js/runtime 1.0.0

package/lib/environment-store.js

@@ -0,0 +1,300 @@
+import { createToken } from '@zhin.js/plugin-runtime';
+export const envStoreToken = createToken('zhin.env', 'Owner-scoped environment variables');
+export class EnvironmentVariableMissingError extends Error {
+    owner;
+    key;
+    constructor(owner, key) {
+        super(`Missing environment variable ${key} for Plugin ${owner}`);
+        this.owner = owner;
+        this.key = key;
+        this.name = 'EnvironmentVariableMissingError';
+    }
+}
+export class EnvSchemaParseError extends Error {
+    owner;
+    constructor(owner, message) {
+        super(`Invalid environment for Plugin ${owner}: ${message}`);
+        this.owner = owner;
+        this.name = 'EnvSchemaParseError';
+    }
+}
+export function defineEnvSchema(schema) {
+    const secretKeys = Object.freeze([...(schema.secretKeys ?? [])]);
+    for (const key of secretKeys)
+        assertEnvironmentKey(key);
+    return Object.freeze({
+        secretKeys,
+        parse: (source) => schema.parse(source),
+    });
+}
+export function defineEnvironmentLayers(layers = {}) {
+    const environments = Object.fromEntries(Object.entries(layers.environments ?? {}).map(([name, source]) => {
+        if (!/^[a-z0-9][a-z0-9-]*$/u.test(name)) {
+            throw new TypeError(`Invalid environment overlay name: ${name}`);
+        }
+        return [name, copySource(source, `environment ${name}`)];
+    }));
+    const plugins = Object.fromEntries(Object.entries(layers.plugins ?? {}).map(([owner, source]) => {
+        if (!/^root(?:\/[a-z0-9][a-z0-9-]*)*$/u.test(owner)) {
+            throw new TypeError(`Invalid Plugin environment overlay owner: ${owner}`);
+        }
+        return [owner, copySource(source, `Plugin ${owner}`)];
+    }));
+    return Object.freeze({
+        base: copySource(layers.base ?? {}, 'base environment'),
+        environments: Object.freeze(environments),
+        plugins: Object.freeze(plugins),
+    });
+}
+export function createEnvStore(owner, environment, layers = {}) {
+    return new EnvStoreFactory(environment, layers).create(owner);
+}
+/** Normalizes layers once, then derives immutable stores for each Plugin owner. */
+export class EnvStoreFactory {
+    #environment;
+    #layers;
+    constructor(environment, layers = {}) {
+        this.#environment = environment;
+        this.#layers = defineEnvironmentLayers(layers);
+    }
+    create(owner) {
+        const source = {};
+        applyLayer(source, this.#layers.base);
+        applyLayer(source, this.#layers.environments?.[this.#environment.name]);
+        for (const ancestor of pluginAncestors(owner)) {
+            applyLayer(source, this.#layers.plugins?.[ancestor]);
+        }
+        return new OwnerEnvStore(owner, this.#environment, Object.freeze(source));
+    }
+}
+class OwnerEnvStore {
+    owner;
+    environment;
+    #source;
+    constructor(owner, environment, source) {
+        this.owner = owner;
+        this.environment = environment;
+        this.#source = source;
+    }
+    has(key) {
+        assertEnvironmentKey(key);
+        return Object.hasOwn(this.#source, key);
+    }
+    get(key) {
+        assertEnvironmentKey(key);
+        return this.#source[key];
+    }
+    require(key) {
+        const value = this.get(key);
+        if (value === undefined)
+            throw new EnvironmentVariableMissingError(this.owner, key);
+        return value;
+    }
+    parse(schema) {
+        const secretKeys = schema.secretKeys ?? [];
+        for (const key of secretKeys)
+            assertEnvironmentKey(key);
+        try {
+            return freezeValue(schema.parse(this.#source));
+        }
+        catch (error) {
+            // Do not retain the original cause: validation libraries commonly embed
+            // source values in it, which would bypass the redacted public message.
+            const message = error instanceof Error ? error.message : String(error);
+            throw new EnvSchemaParseError(this.owner, redactString(message, secretValues(this.#source, secretKeys)));
+        }
+    }
+    expand(value) {
+        return expandValue(value, (key) => this.get(key), (key) => {
+            throw new EnvironmentVariableMissingError(this.owner, key);
+        });
+    }
+    expandMissingAsEmpty(value) {
+        return expandValue(value, (key) => this.get(key), () => '');
+    }
+    redact(value, secretKeys) {
+        for (const key of secretKeys)
+            assertEnvironmentKey(key);
+        return redactValue(value, secretValues(this.#source, secretKeys));
+    }
+}
+function copySource(source, label) {
+    if (!source || typeof source !== 'object' || Array.isArray(source)) {
+        throw new TypeError(`${label} must be an object`);
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(source)) {
+        assertEnvironmentKey(key);
+        if (value !== undefined && typeof value !== 'string') {
+            throw new TypeError(`${label}.${key} must be a string or undefined`);
+        }
+        result[key] = value;
+    }
+    return Object.freeze(result);
+}
+function applyLayer(target, layer) {
+    for (const [key, value] of Object.entries(layer ?? {})) {
+        if (value === undefined)
+            delete target[key];
+        else
+            target[key] = value;
+    }
+}
+function pluginAncestors(owner) {
+    const segments = owner.split('/');
+    return Object.freeze(segments.map((_, index) => segments.slice(0, index + 1).join('/')));
+}
+function assertEnvironmentKey(key) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(key)) {
+        throw new TypeError(`Invalid environment variable name: ${key}`);
+    }
+}
+/**
+ * Standalone deep expansion over an arbitrary config value (e.g. a raw `ai`
+ * config document before EnvStore scoping exists). Supports `${VAR}` and
+ * `${VAR:-default}` / `${VAR:=default}` (default applies when the variable is
+ * unset or empty). Missing plain references resolve via `onMissing`
+ * (default: `""`, matching `EnvStore.expandMissingAsEmpty`).
+ */
+export function expandEnvironmentValue(value, lookup, onMissing = () => '') {
+    return expandValue(value, lookup, onMissing);
+}
+function expandValue(value, lookup, onMissing, seen = new WeakSet()) {
+    if (typeof value === 'string') {
+        return expandString(value, lookup, onMissing);
+    }
+    if (!value || typeof value !== 'object')
+        return value;
+    if (seen.has(value))
+        throw new TypeError('Environment expansion input must be acyclic');
+    seen.add(value);
+    if (Array.isArray(value)) {
+        const result = Object.freeze(value.map((item) => expandValue(item, lookup, onMissing, seen)));
+        seen.delete(value);
+        return result;
+    }
+    if (!isPlainRecord(value)) {
+        seen.delete(value);
+        return value;
+    }
+    const result = Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, expandValue(item, lookup, onMissing, seen)])));
+    seen.delete(value);
+    return result;
+}
+function isEnvKeyStart(ch) {
+    return (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || ch === '_';
+}
+function isEnvKeyChar(ch) {
+    return isEnvKeyStart(ch) || (ch >= '0' && ch <= '9');
+}
+/**
+ * 线性扫描展开 `${VAR}` 与 `${VAR:-default}` / `${VAR:=default}`。
+ * 语义与正则 `/\$\{([A-Za-z_][A-Za-z0-9_]*)(?::[-=]([^}]*))?\}/gu` 完全一致
+ * （解析失败时从 `${` 之后重新找下一个候选，等价于正则引擎逐位后移），
+ * 但全程无回溯（js/polynomial-redos）。
+ */
+function expandString(input, lookup, onMissing) {
+    let out = '';
+    let i = 0;
+    while (i < input.length) {
+        const start = input.indexOf('${', i);
+        if (start < 0)
+            break;
+        let j = start + 2;
+        if (j >= input.length || !isEnvKeyStart(input[j])) {
+            out += input.slice(i, start + 1);
+            i = start + 1;
+            continue;
+        }
+        j += 1;
+        while (j < input.length && isEnvKeyChar(input[j]))
+            j += 1;
+        const key = input.slice(start + 2, j);
+        let fallback;
+        if (input[j] === ':' && (input[j + 1] === '-' || input[j + 1] === '=')) {
+            const close = input.indexOf('}', j + 2);
+            if (close < 0) {
+                out += input.slice(i, start + 1);
+                i = start + 1;
+                continue;
+            }
+            fallback = input.slice(j + 2, close);
+            j = close;
+        }
+        if (input[j] !== '}') {
+            out += input.slice(i, start + 1);
+            i = start + 1;
+            continue;
+        }
+        out += input.slice(i, start);
+        const resolved = lookup(key);
+        if (fallback !== undefined) {
+            out += resolved !== undefined && resolved !== '' ? resolved : fallback;
+        }
+        else if (resolved !== undefined) {
+            out += resolved;
+        }
+        else {
+            out += onMissing(key);
+        }
+        i = j + 1;
+    }
+    return out + input.slice(i);
+}
+function redactValue(value, secrets, seen = new WeakSet()) {
+    if (typeof value === 'string')
+        return redactString(value, secrets);
+    if (!value || typeof value !== 'object')
+        return value;
+    if (seen.has(value))
+        return '[Circular]';
+    seen.add(value);
+    if (value instanceof Error) {
+        const result = Object.freeze({
+            name: value.name,
+            message: redactString(value.message, secrets),
+            stack: value.stack ? redactString(value.stack, secrets) : undefined,
+            cause: value.cause === undefined ? undefined : redactValue(value.cause, secrets, seen),
+        });
+        seen.delete(value);
+        return result;
+    }
+    if (Array.isArray(value)) {
+        const result = Object.freeze(value.map((item) => redactValue(item, secrets, seen)));
+        seen.delete(value);
+        return result;
+    }
+    if (!isPlainRecord(value)) {
+        seen.delete(value);
+        return value;
+    }
+    const result = Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactValue(item, secrets, seen)])));
+    seen.delete(value);
+    return result;
+}
+function redactString(value, secrets) {
+    return secrets.reduce((result, secret) => result.replaceAll(secret, '[REDACTED]'), value);
+}
+function secretValues(source, keys) {
+    return Object.freeze(keys.flatMap((key) => {
+        const value = source[key];
+        return value ? [value] : [];
+    }));
+}
+function freezeValue(value, seen = new WeakSet()) {
+    if (!value || typeof value !== 'object' || seen.has(value))
+        return value;
+    seen.add(value);
+    if (Array.isArray(value) || isPlainRecord(value)) {
+        for (const item of Object.values(value))
+            freezeValue(item, seen);
+        Object.freeze(value);
+    }
+    return value;
+}
+function isPlainRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/lib/environment.d.ts

@@ -0,0 +1,8 @@
+export type RuntimeMode = 'development' | 'test' | 'production';
+export interface RuntimeEnvironment {
+    readonly name: string;
+    readonly mode: RuntimeMode;
+    readonly platform: string;
+}
+export declare const runtimeEnvironmentToken: import("@zhin.js/plugin-runtime").Token<RuntimeEnvironment>;
+export declare function defineRuntimeEnvironment(environment: RuntimeEnvironment): Readonly<RuntimeEnvironment>;

package/lib/environment.js

@@ -0,0 +1,13 @@
+import { createToken } from '@zhin.js/plugin-runtime';
+export const runtimeEnvironmentToken = createToken('zhin.runtime-environment', 'Explicit Root runtime environment');
+export function defineRuntimeEnvironment(environment) {
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(environment.name)) {
+        throw new TypeError(`Invalid environment name: ${environment.name}`);
+    }
+    if (!['development', 'test', 'production'].includes(environment.mode)) {
+        throw new TypeError(`Invalid runtime mode: ${environment.mode}`);
+    }
+    if (!environment.platform)
+        throw new TypeError('Runtime platform is required');
+    return Object.freeze({ ...environment });
+}

package/lib/feature-projector.d.ts

@@ -0,0 +1,15 @@
+import { type Dispose, type GenerationHandoff, type SnapshotState } from '@zhin.js/plugin-runtime';
+import type { FeatureProvider } from '@zhin.js/feature-kit';
+export type ProjectionState = Omit<SnapshotState, 'projections'>;
+export interface ProjectedFeatures {
+    readonly state: SnapshotState;
+    readonly disposers: readonly Dispose[];
+    readonly handoff?: GenerationHandoff;
+}
+/** Builds every Feature projection against one coherent candidate snapshot. */
+export declare class FeatureProjector {
+    private readonly providers;
+    constructor(providers: Iterable<FeatureProvider>);
+    project(generation: number, base: ProjectionState): Promise<ProjectedFeatures>;
+}
+export declare function composeGenerationHandoffs(...handoffs: readonly (GenerationHandoff | undefined)[]): GenerationHandoff | undefined;

package/lib/feature-projector.js

@@ -0,0 +1,57 @@
+import { DisposeStack, GenerationHandoffStack, createSnapshotView, } from '@zhin.js/plugin-runtime';
+/** Builds every Feature projection against one coherent candidate snapshot. */
+export class FeatureProjector {
+    providers;
+    constructor(providers) {
+        this.providers = providers;
+    }
+    async project(generation, base) {
+        const projections = new Map();
+        const disposers = [];
+        const handoffs = new GenerationHandoffStack();
+        const state = { ...base, projections };
+        try {
+            // A projection may capture its snapshot. Rebuilding every projection
+            // prevents unchanged Features from retaining an older generation.
+            for (const provider of this.providers) {
+                const slots = [...base.capabilities.values()].filter((slot) => slot.feature === provider.id);
+                const projection = await provider.runtime.project(slots, {
+                    snapshot: createSnapshotView(generation, state),
+                });
+                projections.set(provider.id, projection.value);
+                if (projection.dispose)
+                    disposers.push(projection.dispose);
+                if (projection.handoff)
+                    handoffs.add(projection.handoff);
+            }
+            return {
+                state,
+                disposers: Object.freeze(disposers),
+                handoff: handoffs.seal(),
+            };
+        }
+        catch (error) {
+            await rollback(disposers, error);
+            throw error;
+        }
+    }
+}
+export function composeGenerationHandoffs(...handoffs) {
+    const stack = new GenerationHandoffStack();
+    for (const handoff of handoffs) {
+        if (handoff)
+            stack.add(handoff);
+    }
+    return stack.seal();
+}
+async function rollback(disposers, prepareError) {
+    const stack = new DisposeStack();
+    for (const dispose of disposers)
+        stack.add(dispose);
+    try {
+        await stack.dispose();
+    }
+    catch (disposeError) {
+        throw new AggregateError([prepareError, disposeError], 'Feature projection and rollback both failed', { cause: disposeError });
+    }
+}

package/lib/generation-assets.d.ts

@@ -0,0 +1,9 @@
+import { type Dispose, type PluginId } from '@zhin.js/plugin-runtime';
+export declare class GenerationAssets {
+    #private;
+    private constructor();
+    static create(scopeDisposers: Iterable<readonly [PluginId, Dispose]>, projectionDisposers: Iterable<Dispose>): GenerationAssets;
+    fork(projectionDisposers: Iterable<Dispose>): GenerationAssets;
+    replaceScopes(scopeOrder: readonly PluginId[], replacements: ReadonlyMap<PluginId, Dispose>, projectionDisposers: Iterable<Dispose>): GenerationAssets;
+    dispose(): Promise<void>;
+}

package/lib/generation-assets.js

@@ -0,0 +1,67 @@
+import { DisposeStack, SharedLifetime, } from '@zhin.js/plugin-runtime';
+export class GenerationAssets {
+    #scopeLifetimes;
+    #disposers = new DisposeStack();
+    constructor(scopeOrder, scopeLifetimes, projectionDisposers) {
+        this.#scopeLifetimes = scopeLifetimes;
+        assertScopeOrder(scopeOrder, scopeLifetimes);
+        // Scope order is parent-first. DisposeStack unwinds projections first,
+        // then Plugin leases children-first, so no child observes a closed parent.
+        for (const owner of scopeOrder) {
+            const lifetime = scopeLifetimes.get(owner);
+            if (!lifetime)
+                throw new Error(`Missing Scope lifetime for ${owner}`);
+            const lease = lifetime.acquire();
+            this.#disposers.add(() => lease.release());
+        }
+        for (const dispose of projectionDisposers)
+            this.#disposers.add(dispose);
+        this.#disposers.seal();
+    }
+    static create(scopeDisposers, projectionDisposers) {
+        const lifetimes = new Map();
+        for (const [owner, dispose] of scopeDisposers) {
+            if (lifetimes.has(owner))
+                throw new Error(`Duplicate Plugin Scope: ${owner}`);
+            lifetimes.set(owner, new SharedLifetime(dispose));
+        }
+        return new GenerationAssets([...lifetimes.keys()], lifetimes, projectionDisposers);
+    }
+    fork(projectionDisposers) {
+        return new GenerationAssets([...this.#scopeLifetimes.keys()], this.#scopeLifetimes, projectionDisposers);
+    }
+    replaceScopes(scopeOrder, replacements, projectionDisposers) {
+        const owners = new Set(scopeOrder);
+        for (const owner of replacements.keys()) {
+            if (!owners.has(owner))
+                throw new Error(`Replacement Scope is not mounted: ${owner}`);
+        }
+        const lifetimes = new Map();
+        for (const owner of scopeOrder) {
+            const replacement = replacements.get(owner);
+            const lifetime = replacement
+                ? new SharedLifetime(replacement)
+                : this.#scopeLifetimes.get(owner);
+            if (!lifetime)
+                throw new Error(`Cannot retain unknown Plugin Scope: ${owner}`);
+            lifetimes.set(owner, lifetime);
+        }
+        return new GenerationAssets(scopeOrder, lifetimes, projectionDisposers);
+    }
+    dispose() {
+        return this.#disposers.dispose();
+    }
+}
+function assertScopeOrder(scopeOrder, lifetimes) {
+    const owners = new Set();
+    for (const owner of scopeOrder) {
+        if (owners.has(owner))
+            throw new Error(`Duplicate Plugin Scope: ${owner}`);
+        if (!lifetimes.has(owner))
+            throw new Error(`Missing Scope lifetime for ${owner}`);
+        owners.add(owner);
+    }
+    if (owners.size !== lifetimes.size) {
+        throw new Error('Scope order does not include every Plugin Scope lifetime');
+    }
+}

package/lib/hmr-coordinator.d.ts

@@ -0,0 +1,23 @@
+import type { Dispose } from '@zhin.js/plugin-runtime';
+import { type GenerationInvalidationPlan, type InvalidationPlan, type ProcessInvalidationPlan } from './invalidation-planner.js';
+import type { ModuleRuntime } from './module-runtime.js';
+import type { SourceOwnershipIndex } from './source-ownership.js';
+export interface HmrReloadPort {
+    reload(plan: GenerationInvalidationPlan): Promise<ProcessInvalidationPlan | void>;
+}
+export interface HmrCoordinatorOptions {
+    readonly modules: ModuleRuntime;
+    readonly ownership: () => SourceOwnershipIndex;
+    readonly runtime: HmrReloadPort;
+    onRestartRequired(plan: ProcessInvalidationPlan): void | Promise<void>;
+    onError(error: unknown): void | Promise<void>;
+    onPlan?(plan: InvalidationPlan): void | Promise<void>;
+}
+export declare class HmrCoordinator {
+    #private;
+    private readonly options;
+    constructor(options: HmrCoordinatorOptions);
+    start(): Dispose;
+    stop(): void;
+    enqueue(source: string): Promise<void>;
+}

package/lib/hmr-coordinator.js

@@ -0,0 +1,110 @@
+import { InvalidationPlanner, } from './invalidation-planner.js';
+export class HmrCoordinator {
+    options;
+    #pending = new Set();
+    #waiters = [];
+    #draining;
+    #unwatch;
+    constructor(options) {
+        this.options = options;
+    }
+    start() {
+        if (this.#unwatch)
+            throw new Error('HmrCoordinator is already started');
+        if (!this.options.modules.watch) {
+            throw new Error('ModuleRuntime does not provide a file watcher');
+        }
+        this.#unwatch = this.options.modules.watch((source) => {
+            void this.enqueue(source).catch(() => undefined);
+        });
+        return () => this.stop();
+    }
+    stop() {
+        this.#unwatch?.();
+        this.#unwatch = undefined;
+    }
+    enqueue(source) {
+        this.#pending.add(source);
+        const completed = new Promise((resolve, reject) => {
+            this.#waiters.push({ resolve, reject });
+        });
+        // Starting on a microtask batches add/change/unlink events emitted for the
+        // same filesystem operation into one generation transaction.
+        this.#ensureDrain();
+        return completed;
+    }
+    #ensureDrain() {
+        if (this.#draining)
+            return;
+        // Individual enqueue promises carry failures to callers. Keep the shared
+        // scheduler promise handled even when an onError hook itself fails.
+        this.#draining = Promise.resolve()
+            .then(() => this.#drain())
+            .catch(() => undefined);
+    }
+    async #drain() {
+        try {
+            while (this.#pending.size > 0) {
+                const changed = [...this.#pending];
+                this.#pending.clear();
+                const forcedRestart = changed.filter((source) => this.options.modules.requiresProcessRestart?.(source));
+                if (forcedRestart.length > 0) {
+                    await this.options.onRestartRequired(Object.freeze({
+                        kind: 'process',
+                        changed: Object.freeze(changed),
+                        reasons: Object.freeze([
+                            `Module loader cannot safely invalidate: ${forcedRestart.join(', ')}`,
+                        ]),
+                    }));
+                    continue;
+                }
+                const dependencyPort = this.options.modules.affectedSources
+                    ? {
+                        affectedSources: (source) => this.options.modules.affectedSources?.(source) ?? [source],
+                    }
+                    : undefined;
+                const plan = new InvalidationPlanner(this.options.ownership(), dependencyPort).plan(changed);
+                await this.options.onPlan?.(plan);
+                if (plan.kind === 'process') {
+                    await this.options.onRestartRequired(plan);
+                    continue;
+                }
+                if (plan.kind === 'none')
+                    continue;
+                for (const source of plan.changed) {
+                    await this.options.modules.invalidate?.(source);
+                }
+                const restart = await this.options.runtime.reload(plan);
+                if (restart)
+                    await this.options.onRestartRequired(restart);
+            }
+            this.#resolveWaiters();
+        }
+        catch (error) {
+            // A failed transaction invalidates the rest of this burst as well. Do
+            // not replay queued paths without their callers explicitly retrying.
+            this.#pending.clear();
+            try {
+                await this.options.onError(error);
+            }
+            finally {
+                this.#rejectWaiters(error);
+            }
+        }
+        finally {
+            this.#draining = undefined;
+            // A source may arrive after the loop observed an empty queue but before
+            // this promise settled. Keep its waiter attached to a fresh transaction.
+            if (this.#pending.size > 0)
+                this.#ensureDrain();
+        }
+    }
+    #resolveWaiters() {
+        for (const waiter of this.#waiters.splice(0))
+            waiter.resolve();
+    }
+    #rejectWaiters(error) {
+        for (const waiter of this.#waiters.splice(0))
+            waiter.reject(error);
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,21 @@
+export * from './config-composer.js';
+export * from './config-document.js';
+export * from './config-patch-planner.js';
+export * from './compatibility.js';
+export * from './environment.js';
+export * from './environment-store.js';
+export * from './hmr-coordinator.js';
+export * from './invalidation-planner.js';
+export * from './isolation.js';
+export * from './manifest.js';
+export * from './module-runtime.js';
+export * from './native-development-runtime.js';
+export * from './node-discovery-host.js';
+export * from './package-resolver.js';
+export * from './project-graph.js';
+export * from './process-restart.js';
+export * from './restart-boundary.js';
+export * from './root-runtime.js';
+export * from './source-ownership.js';
+export * from './topology-transaction.js';
+export * from './typescript-specifier-remap.js';

package/lib/index.js

@@ -0,0 +1,21 @@
+export * from './config-composer.js';
+export * from './config-document.js';
+export * from './config-patch-planner.js';
+export * from './compatibility.js';
+export * from './environment.js';
+export * from './environment-store.js';
+export * from './hmr-coordinator.js';
+export * from './invalidation-planner.js';
+export * from './isolation.js';
+export * from './manifest.js';
+export * from './module-runtime.js';
+export * from './native-development-runtime.js';
+export * from './node-discovery-host.js';
+export * from './package-resolver.js';
+export * from './project-graph.js';
+export * from './process-restart.js';
+export * from './restart-boundary.js';
+export * from './root-runtime.js';
+export * from './source-ownership.js';
+export * from './topology-transaction.js';
+export * from './typescript-specifier-remap.js';

package/lib/invalidation-planner.d.ts

@@ -0,0 +1,29 @@
+import { type CapabilityId, type PluginId } from '@zhin.js/plugin-runtime';
+import type { SourceOwnershipIndex } from './source-ownership.js';
+export interface DependencyImpactPort {
+    affectedSources(source: string): readonly string[];
+}
+export interface NoInvalidationPlan {
+    readonly kind: 'none';
+    readonly changed: readonly string[];
+    readonly reasons: readonly string[];
+}
+export interface GenerationInvalidationPlan {
+    readonly kind: 'generation';
+    readonly changed: readonly string[];
+    readonly slots: readonly CapabilityId[];
+    readonly subtrees: readonly PluginId[];
+    readonly reasons: readonly string[];
+}
+export interface ProcessInvalidationPlan {
+    readonly kind: 'process';
+    readonly changed: readonly string[];
+    readonly reasons: readonly string[];
+}
+export type InvalidationPlan = NoInvalidationPlan | GenerationInvalidationPlan | ProcessInvalidationPlan;
+export declare class InvalidationPlanner {
+    private readonly ownership;
+    private readonly dependencies?;
+    constructor(ownership: SourceOwnershipIndex, dependencies?: DependencyImpactPort | undefined);
+    plan(sources: readonly string[]): InvalidationPlan;
+}