@zhin.js/runtime 1.0.0

package/lib/root-runtime.js

@@ -0,0 +1,432 @@
+import { resolve } from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import { DisposeStack, GenerationHandoffStack, RootController, createSnapshotView, rootPluginId, } from '@zhin.js/plugin-runtime';
+import { FeatureCatalog, FeatureDiscovery, } from '@zhin.js/feature-kit';
+import { ConfigComposer } from './config-composer.js';
+import { ConfigDocumentDivergenceError, } from './config-document.js';
+import { ConfigPatchPlanner, } from './config-patch-planner.js';
+import { defineRuntimeEnvironment } from './environment.js';
+import { createEnvStore, defineEnvironmentLayers, } from './environment-store.js';
+import { FeatureProjector, composeGenerationHandoffs, } from './feature-projector.js';
+import { GenerationAssets } from './generation-assets.js';
+import { NodeDiscoveryHost } from './node-discovery-host.js';
+import { NodePackageResolver } from './package-resolver.js';
+import { PluginScopeAssembler, } from './plugin-scope-assembler.js';
+import { ProjectGraphService } from './project-graph.js';
+import { HmrCoordinator } from './hmr-coordinator.js';
+import { RootProcessRestartExecutor, } from './process-restart.js';
+import { SlotGenerationPreparer } from './slot-generation-preparer.js';
+import { SourceOwnershipIndex } from './source-ownership.js';
+import { SubtreeGenerationPreparer, SubtreeTopologyChangedError, } from './subtree-generation-preparer.js';
+import { TopologyGenerationPreparer } from './topology-generation-preparer.js';
+import { RestartBoundaryPlanner } from './restart-boundary.js';
+export class RootRuntime {
+    controller;
+    #projectRoot;
+    #modules;
+    #environment;
+    #environmentLayers;
+    #configResolver;
+    #configPort;
+    #configSnapshot;
+    #configDocument;
+    #installResources;
+    #isolation;
+    #ownership = SourceOwnershipIndex.empty();
+    #model;
+    #configPatchTail = Promise.resolve();
+    constructor(options) {
+        this.#projectRoot = resolve(options.projectRoot);
+        this.#modules = options.modules;
+        this.#environment = defineRuntimeEnvironment(options.environment);
+        this.#environmentLayers = defineEnvironmentLayers(options.environmentVariables);
+        if (typeof options.config === 'function')
+            this.#configResolver = options.config;
+        else if (isConfigDocumentPort(options.config))
+            this.#configPort = options.config;
+        else
+            this.#configDocument = structuredClone(options.config ?? {});
+        this.#installResources = options.installResources;
+        this.#isolation = options.isolation;
+        this.controller = new RootController(emptyState(), options.onControlError);
+    }
+    get snapshot() {
+        return this.controller.snapshots.current;
+    }
+    get sourceOwnership() {
+        return this.#ownership;
+    }
+    async start() {
+        if (this.#configPort) {
+            const snapshot = await this.#configPort.read();
+            this.#configSnapshot = snapshot;
+            this.#configDocument = structuredClone(snapshot.document);
+        }
+        let prepared;
+        const snapshot = await this.controller.start(async (current) => {
+            prepared = await this.#prepare(current);
+            return prepared.generation;
+        });
+        this.#accept(requirePrepared(prepared));
+        return snapshot;
+    }
+    async reload(target = rootPluginId()) {
+        let prepared;
+        const snapshot = await this.controller.reload(target, async (current) => {
+            prepared = await this.#prepare(current);
+            return prepared.generation;
+        });
+        this.#accept(requirePrepared(prepared));
+        return snapshot;
+    }
+    patchConfig(patches) {
+        const operations = cloneConfigPatches(patches);
+        const result = this.#configPatchTail.then(() => this.#applyConfigPatches(operations), () => this.#applyConfigPatches(operations));
+        this.#configPatchTail = result.catch(() => undefined);
+        return result;
+    }
+    createHmrCoordinator(options) {
+        return new HmrCoordinator({
+            ...options,
+            modules: this.#modules,
+            ownership: () => this.#ownership,
+            runtime: {
+                reload: async (plan) => {
+                    const result = await this.#reloadPlan(plan);
+                    return isProcessPlan(result) ? result : undefined;
+                },
+            },
+        });
+    }
+    createProcessRestartExecutor(adapter) {
+        return new RootProcessRestartExecutor(this, adapter);
+    }
+    async stop() {
+        try {
+            await this.controller.stop();
+        }
+        finally {
+            await this.#modules.close();
+        }
+    }
+    async #reloadPlan(plan) {
+        let prepared;
+        let restart;
+        const snapshot = await this.controller.reload(plan.subtrees[0] ?? plan.slots[0] ?? rootPluginId(), async (current) => {
+            if (this.#model && this.#isManifestTopologyPlan(plan)) {
+                const inspected = await this.#inspectProject();
+                restart = new RestartBoundaryPlanner().plan(this.#model.graph, inspected.graph, plan.changed);
+                if (restart)
+                    return undefined;
+                prepared = await new TopologyGenerationPreparer(this.#modules, this.#model, inspected.graph, inspected.configResolver, this.#environment, this.#installResources, this.#environmentLayers, this.#isolation).prepare(current);
+            }
+            else if (plan.subtrees.length === 0 && plan.slots.length > 0 && this.#model) {
+                prepared = await new SlotGenerationPreparer(this.#modules, this.#model)
+                    .prepare(current, plan.slots);
+            }
+            else if (this.#model && this.#canPrepareSubtrees(plan)) {
+                const inspected = await this.#inspectProject();
+                prepared = await this.#prepareSubtrees(current, inspected, plan.subtrees);
+            }
+            else {
+                prepared = await this.#prepare(current);
+            }
+            return prepared?.generation;
+        });
+        if (restart)
+            return restart;
+        if (prepared)
+            this.#accept(prepared);
+        return snapshot;
+    }
+    #isManifestTopologyPlan(plan) {
+        let manifest = false;
+        for (const source of plan.changed) {
+            const records = this.#ownership.recordsFor(source);
+            if (records.some((record) => record.role === 'manifest'))
+                manifest = true;
+            if (records.some((record) => record.role !== 'manifest'))
+                return false;
+        }
+        return manifest;
+    }
+    #accept(prepared) {
+        this.#ownership = prepared.ownership;
+        this.#model = prepared.model;
+    }
+    #canPrepareSubtrees(plan) {
+        if (plan.subtrees.length === 0 || plan.subtrees.includes(rootPluginId()))
+            return false;
+        return plan.changed.every((source) => {
+            const records = this.#ownership.recordsFor(source);
+            return records.length > 0 && records.every((record) => record.role === 'plugin' || record.role === 'schema');
+        });
+    }
+    async #prepare(current) {
+        return this.#prepareInspected(current, await this.#inspectProject());
+    }
+    async #inspectProject() {
+        const resolver = await NodePackageResolver.create(this.#projectRoot);
+        const graph = await new ProjectGraphService(resolver).inspect(this.#projectRoot);
+        const configResolver = this.#configResolver
+            ? this.#configResolver
+            : await new ConfigComposer()
+                .compose(graph, this.#configDocument)
+                .then((composed) => this.#configViewResolver(composed.views));
+        return { graph, configResolver };
+    }
+    #configViewResolver(views) {
+        const env = createEnvStore(rootPluginId(), this.#environment, this.#environmentLayers);
+        return (node) => {
+            const view = views.get(node.id);
+            if (view === undefined)
+                return undefined;
+            return env.expandMissingAsEmpty(view);
+        };
+    }
+    async #applyConfigPatches(patches) {
+        if (!this.#configDocument) {
+            throw new Error('Config patches require a document-backed RootRuntime config');
+        }
+        const currentDocument = this.#configDocument;
+        let plan;
+        let prepared;
+        let documentTransaction;
+        let committedDocument;
+        const snapshot = await this.controller.reload(rootPluginId(), async (current) => {
+            const resolver = await NodePackageResolver.create(this.#projectRoot);
+            const graph = await new ProjectGraphService(resolver).inspect(this.#projectRoot);
+            const planned = await new ConfigPatchPlanner().plan(graph, currentDocument, patches);
+            plan = planned;
+            if (!planned.documentChanged)
+                return undefined;
+            if (this.#configPort) {
+                const currentSnapshot = requireConfigDocumentSnapshot(this.#configSnapshot);
+                // Port preparation must remain inert; validation and shadow setup can
+                // still reject this candidate without touching the backing document.
+                documentTransaction = await this.#configPort.prepare(currentSnapshot, patches);
+                if (!isDeepStrictEqual(documentTransaction.document, planned.candidate)) {
+                    throw new ConfigDocumentDivergenceError();
+                }
+            }
+            if (planned.roots.length === 0) {
+                if (documentTransaction)
+                    committedDocument = await documentTransaction.commit();
+                return undefined;
+            }
+            const inspected = {
+                graph,
+                configResolver: this.#configViewResolver(planned.views),
+            };
+            if (this.#model && !planned.roots.includes(rootPluginId())) {
+                prepared = await this.#prepareSubtrees(current, inspected, planned.roots);
+            }
+            else {
+                prepared = await this.#prepareInspected(current, inspected);
+            }
+            return documentTransaction
+                ? withConfigDocumentHandoff(prepared.generation, documentTransaction, (committed) => { committedDocument = committed; })
+                : prepared.generation;
+        });
+        const completed = requireConfigPatchPlan(plan);
+        if (prepared)
+            this.#accept(prepared);
+        this.#configDocument = completed.candidate;
+        if (committedDocument)
+            this.#configSnapshot = committedDocument;
+        return snapshot;
+    }
+    #prepareInspected(current, inspected) {
+        const assembler = new GenerationAssembler(inspected.graph, this.#modules, inspected.configResolver, current.generation + 1, this.#environment, this.#installResources, this.#environmentLayers, this.#isolation);
+        return assembler.prepare();
+    }
+    async #prepareSubtrees(current, inspected, roots) {
+        if (!this.#model)
+            return this.#prepareInspected(current, inspected);
+        try {
+            return await new SubtreeGenerationPreparer(this.#modules, this.#model, inspected.graph, inspected.configResolver, this.#environment, this.#installResources, this.#environmentLayers, this.#isolation).prepare(current, roots);
+        }
+        catch (error) {
+            if (!(error instanceof SubtreeTopologyChangedError))
+                throw error;
+            return this.#prepareInspected(current, inspected);
+        }
+    }
+}
+function withConfigDocumentHandoff(generation, document, committed) {
+    const handoffs = new GenerationHandoffStack();
+    if (generation.handoff)
+        handoffs.add(generation.handoff);
+    // File commit follows Resource activation, so reverse compensation restores
+    // the document before it deactivates the shadow generation.
+    handoffs.add({
+        async activateNext() {
+            committed(await document.commit());
+        },
+        deactivateNext: () => document.rollback(),
+    });
+    return { ...generation, handoff: handoffs.seal() };
+}
+function isConfigDocumentPort(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return typeof candidate.read === 'function' && typeof candidate.prepare === 'function';
+}
+function requireConfigDocumentSnapshot(snapshot) {
+    if (!snapshot)
+        throw new Error('ConfigDocumentPort has not been read');
+    return snapshot;
+}
+function cloneConfigPatches(patches) {
+    return Object.freeze(patches.map((patch) => Object.freeze(patch.op === 'set'
+        ? { ...patch, path: Object.freeze([...patch.path]), value: structuredClone(patch.value) }
+        : { ...patch, path: Object.freeze([...patch.path]) })));
+}
+function requireConfigPatchPlan(plan) {
+    if (!plan)
+        throw new Error('RootController completed without a Config patch plan');
+    return plan;
+}
+class GenerationAssembler {
+    graph;
+    modules;
+    configResolver;
+    generation;
+    environment;
+    installResources;
+    environmentLayers;
+    isolation;
+    #capabilities = new Map();
+    #catalog = new FeatureCatalog();
+    #rootsByFeature = new Map();
+    #featureIdsByPackageRoot = new Map();
+    #projectionDisposers = [];
+    #host;
+    #plugins;
+    constructor(graph, modules, configResolver, generation, environment, installResources, environmentLayers = {}, isolation) {
+        this.graph = graph;
+        this.modules = modules;
+        this.configResolver = configResolver;
+        this.generation = generation;
+        this.environment = environment;
+        this.installResources = installResources;
+        this.environmentLayers = environmentLayers;
+        this.isolation = isolation;
+        this.#host = new NodeDiscoveryHost(modules);
+        this.#plugins = new PluginScopeAssembler(modules, configResolver, environment, installResources, environmentLayers, undefined, isolation);
+    }
+    async prepare() {
+        try {
+            // Prepare is deliberately ordered: providers define discovery, setup
+            // creates owner scopes, then definitions can be projected against both.
+            await this.#loadProviders(this.graph.root);
+            await this.#plugins.setupTree(this.graph.root);
+            await this.#discover();
+            const projected = await new FeatureProjector(this.#catalog.values())
+                .project(this.generation, this.#projectionState());
+            this.#projectionDisposers.push(...projected.disposers);
+            const state = projected.state;
+            const snapshot = createSnapshotView(this.generation, state);
+            const ownership = SourceOwnershipIndex.fromGeneration(this.graph, snapshot, this.#featureIdsByPackageRoot);
+            const assets = GenerationAssets.create(this.#plugins.createdScopeDisposers(), this.#projectionDisposers);
+            return {
+                generation: {
+                    snapshot: state,
+                    dispose: () => assets.dispose(),
+                    handoff: composeGenerationHandoffs(this.#plugins.generationHandoff(), projected.handoff),
+                },
+                ownership,
+                model: {
+                    graph: this.graph,
+                    providers: new Map(this.#catalog.values().map((provider) => [provider.id, provider])),
+                    rootsByFeature: new Map([...this.#rootsByFeature].map(([feature, roots]) => [
+                        feature,
+                        Object.freeze([...roots]),
+                    ])),
+                    featureIdsByPackageRoot: new Map(this.#featureIdsByPackageRoot),
+                    scopes: new Map(this.#plugins.scopes),
+                    assets,
+                },
+            };
+        }
+        catch (error) {
+            await disposePreparedParts(this.#plugins.createdScopeDisposers().map(([, dispose]) => dispose), this.#projectionDisposers, error);
+            throw error;
+        }
+    }
+    async #loadProviders(node) {
+        for (const requirement of node.features) {
+            const manifest = requirement.package.packageJson.zhin;
+            const module = await this.modules.load(resolve(requirement.package.root, manifest.entry));
+            const provider = module.default;
+            if (!provider || provider.protocol !== 1) {
+                throw new TypeError(`${requirement.package.name} does not default-export a Feature provider`);
+            }
+            this.#catalog.add(provider);
+            const packageRoot = resolve(requirement.package.root);
+            const existingFeature = this.#featureIdsByPackageRoot.get(packageRoot);
+            if (existingFeature && existingFeature !== provider.id) {
+                throw new Error(`Feature package ${requirement.package.name} changed identity within one generation`);
+            }
+            this.#featureIdsByPackageRoot.set(packageRoot, provider.id);
+            const roots = this.#rootsByFeature.get(provider.id) ?? [];
+            roots.push({ owner: node.id, packageRoot: node.package.root });
+            this.#rootsByFeature.set(provider.id, roots);
+        }
+        for (const child of node.children)
+            await this.#loadProviders(child);
+    }
+    async #discover() {
+        const discovery = new FeatureDiscovery(this.#host);
+        for (const provider of this.#catalog.values()) {
+            const roots = this.#rootsByFeature.get(provider.id) ?? [];
+            const slots = await discovery.discover(provider, roots);
+            for (const slot of slots)
+                this.#capabilities.set(slot.id, slot);
+        }
+    }
+    #projectionState() {
+        return {
+            root: rootPluginId(),
+            tree: this.#plugins.tree,
+            config: this.#plugins.config,
+            resources: this.#plugins.resources,
+            capabilities: this.#capabilities,
+        };
+    }
+}
+function emptyState() {
+    return {
+        root: rootPluginId(),
+        tree: new Map(),
+        config: new Map(),
+        resources: new Map(),
+        capabilities: new Map(),
+        projections: new Map(),
+    };
+}
+function requirePrepared(prepared) {
+    if (!prepared)
+        throw new Error('RootController committed without a prepared generation');
+    return prepared;
+}
+function isProcessPlan(value) {
+    return 'kind' in value && value.kind === 'process';
+}
+async function disposePreparedParts(scopeDisposers, projectionDisposers, prepareError) {
+    const rollback = new DisposeStack();
+    for (const dispose of scopeDisposers)
+        rollback.add(dispose);
+    for (const dispose of projectionDisposers)
+        rollback.add(dispose);
+    try {
+        await rollback.dispose();
+    }
+    catch (disposeError) {
+        if (prepareError !== undefined) {
+            throw new AggregateError([prepareError, disposeError], 'Generation prepare and rollback both failed', { cause: disposeError });
+        }
+        throw disposeError;
+    }
+}

package/lib/runtime-generation.d.ts

@@ -0,0 +1,18 @@
+import type { FeatureId, PluginId, PreparedGeneration, Scope } from '@zhin.js/plugin-runtime';
+import type { CapabilityRoot, FeatureProvider } from '@zhin.js/feature-kit';
+import type { GenerationAssets } from './generation-assets.js';
+import type { ProjectGraph } from './project-graph.js';
+import type { SourceOwnershipIndex } from './source-ownership.js';
+export interface RuntimeGenerationModel {
+    readonly graph: ProjectGraph;
+    readonly providers: ReadonlyMap<FeatureId, FeatureProvider>;
+    readonly rootsByFeature: ReadonlyMap<FeatureId, readonly CapabilityRoot[]>;
+    readonly featureIdsByPackageRoot: ReadonlyMap<string, FeatureId>;
+    readonly scopes: ReadonlyMap<PluginId, Scope>;
+    readonly assets: GenerationAssets;
+}
+export interface PreparedRuntimeGeneration {
+    readonly generation: PreparedGeneration;
+    readonly ownership: SourceOwnershipIndex;
+    readonly model: RuntimeGenerationModel;
+}

package/lib/runtime-generation.js

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

package/lib/slot-generation-preparer.d.ts

@@ -0,0 +1,9 @@
+import { type CapabilityId, type RuntimeSnapshot } from '@zhin.js/plugin-runtime';
+import type { ModuleRuntime } from './module-runtime.js';
+import type { PreparedRuntimeGeneration, RuntimeGenerationModel } from './runtime-generation.js';
+export declare class SlotGenerationPreparer {
+    private readonly modules;
+    private readonly model;
+    constructor(modules: ModuleRuntime, model: RuntimeGenerationModel);
+    prepare(current: RuntimeSnapshot, selected: readonly CapabilityId[]): Promise<PreparedRuntimeGeneration>;
+}

package/lib/slot-generation-preparer.js

@@ -0,0 +1,76 @@
+import { DisposeStack, createSnapshotView, } from '@zhin.js/plugin-runtime';
+import { FeatureDiscovery } from '@zhin.js/feature-kit';
+import { FeatureProjector, composeGenerationHandoffs } from './feature-projector.js';
+import { NodeDiscoveryHost } from './node-discovery-host.js';
+import { SourceOwnershipIndex } from './source-ownership.js';
+export class SlotGenerationPreparer {
+    modules;
+    model;
+    constructor(modules, model) {
+        this.modules = modules;
+        this.model = model;
+    }
+    async prepare(current, selected) {
+        const selectedByFeature = groupByFeature(current, selected);
+        const capabilities = new Map(current.capabilities);
+        const discovery = new FeatureDiscovery(new NodeDiscoveryHost(this.modules));
+        for (const [feature, ids] of selectedByFeature) {
+            const provider = this.model.providers.get(feature);
+            if (!provider)
+                throw new Error(`Missing Feature provider for ${feature}`);
+            for (const id of ids)
+                capabilities.delete(id);
+            const replacements = await discovery.discover(provider, this.model.rootsByFeature.get(feature) ?? [], { capabilities: ids });
+            for (const slot of replacements)
+                capabilities.set(slot.id, slot);
+        }
+        const projected = await new FeatureProjector(this.model.providers.values()).project(current.generation + 1, {
+            root: current.root,
+            tree: current.tree,
+            config: current.config,
+            resources: current.resources,
+            capabilities,
+        });
+        try {
+            const snapshot = createSnapshotView(current.generation + 1, projected.state);
+            const ownership = SourceOwnershipIndex.fromGeneration(this.model.graph, snapshot, this.model.featureIdsByPackageRoot);
+            const assets = this.model.assets.fork(projected.disposers);
+            return {
+                generation: {
+                    snapshot: projected.state,
+                    dispose: () => assets.dispose(),
+                    handoff: composeGenerationHandoffs(projected.handoff),
+                },
+                ownership,
+                model: { ...this.model, assets },
+            };
+        }
+        catch (error) {
+            await disposeProjections(projected.disposers, error);
+            throw error;
+        }
+    }
+}
+function groupByFeature(current, selected) {
+    const result = new Map();
+    for (const id of selected) {
+        const slot = current.capabilities.get(id);
+        if (!slot)
+            throw new Error(`Cannot reload missing Capability Slot: ${id}`);
+        const ids = result.get(slot.feature) ?? new Set();
+        ids.add(id);
+        result.set(slot.feature, ids);
+    }
+    return result;
+}
+async function disposeProjections(disposers, prepareError) {
+    const rollback = new DisposeStack();
+    for (const dispose of disposers)
+        rollback.add(dispose);
+    try {
+        await rollback.dispose();
+    }
+    catch (disposeError) {
+        throw new AggregateError([prepareError, disposeError], 'Slot generation prepare and rollback both failed', { cause: disposeError });
+    }
+}

package/lib/source-ownership.d.ts

@@ -0,0 +1,19 @@
+import type { CapabilityId, FeatureId, PluginId, RuntimeSnapshot } from '@zhin.js/plugin-runtime';
+import type { ProjectGraph } from './project-graph.js';
+export type SourceRole = 'plugin' | 'schema' | 'manifest' | 'feature' | 'capability';
+export interface SourceOwnershipRecord {
+    readonly source: string;
+    readonly role: SourceRole;
+    readonly owner: PluginId;
+    readonly capability?: CapabilityId;
+    readonly feature?: FeatureId;
+}
+export declare class SourceOwnershipIndex {
+    #private;
+    static empty(): SourceOwnershipIndex;
+    static fromGeneration(graph: ProjectGraph, snapshot: RuntimeSnapshot, featureIdsByPackageRoot: ReadonlyMap<string, FeatureId>): SourceOwnershipIndex;
+    add(record: SourceOwnershipRecord): void;
+    addPackageRoot(packageRoot: string, owner: PluginId): void;
+    recordsFor(source: string): readonly SourceOwnershipRecord[];
+    ownersForPath(source: string): readonly PluginId[];
+}

package/lib/source-ownership.js

@@ -0,0 +1,105 @@
+import { isAbsolute, relative, resolve } from 'node:path';
+export class SourceOwnershipIndex {
+    #records = new Map();
+    #packages = [];
+    static empty() {
+        return new SourceOwnershipIndex();
+    }
+    static fromGeneration(graph, snapshot, featureIdsByPackageRoot) {
+        const index = new SourceOwnershipIndex();
+        visitPlugin(graph.root, (node) => {
+            index.addPackageRoot(node.package.root, node.id);
+            index.add({
+                source: resolve(node.package.root, node.package.packageJson.zhin.entry),
+                role: 'plugin',
+                owner: node.id,
+            });
+            index.add({
+                source: resolve(node.package.root, 'schema.json'),
+                role: 'schema',
+                owner: node.id,
+            });
+            index.add({
+                source: resolve(node.package.root, 'package.json'),
+                role: 'manifest',
+                owner: node.id,
+            });
+            for (const requirement of node.features) {
+                const packageRoot = resolve(requirement.package.root);
+                index.addPackageRoot(packageRoot, node.id);
+                index.add({
+                    source: resolve(packageRoot, 'package.json'),
+                    role: 'manifest',
+                    owner: node.id,
+                    feature: featureIdsByPackageRoot.get(packageRoot),
+                });
+                index.add({
+                    source: resolve(packageRoot, requirement.package.packageJson.zhin.entry),
+                    role: 'feature',
+                    owner: node.id,
+                    feature: featureIdsByPackageRoot.get(packageRoot),
+                });
+            }
+        });
+        for (const slot of snapshot.capabilities.values()) {
+            index.add({
+                source: slot.source,
+                role: 'capability',
+                owner: slot.owner,
+                capability: slot.id,
+                feature: slot.feature,
+            });
+        }
+        return index;
+    }
+    add(record) {
+        const source = normalizeSource(record.source);
+        const records = this.#records.get(source) ?? [];
+        if (!records.some((item) => sameRecord(item, record))) {
+            records.push(Object.freeze({ ...record, source }));
+            this.#records.set(source, records);
+        }
+    }
+    addPackageRoot(packageRoot, owner) {
+        const normalized = normalizeSource(packageRoot);
+        if (!this.#packages.some((item) => item.packageRoot === normalized && item.owner === owner)) {
+            this.#packages.push(Object.freeze({ packageRoot: normalized, owner }));
+            this.#packages.sort((left, right) => right.packageRoot.length - left.packageRoot.length);
+        }
+    }
+    recordsFor(source) {
+        return Object.freeze([...(this.#records.get(normalizeSource(source)) ?? [])]);
+    }
+    ownersForPath(source) {
+        const normalized = normalizeSource(source);
+        let longest = -1;
+        const owners = new Set();
+        for (const item of this.#packages) {
+            if (!contains(item.packageRoot, normalized))
+                continue;
+            if (item.packageRoot.length < longest)
+                break;
+            longest = item.packageRoot.length;
+            owners.add(item.owner);
+        }
+        return Object.freeze([...owners]);
+    }
+}
+function visitPlugin(node, visit) {
+    visit(node);
+    for (const child of node.children)
+        visitPlugin(child, visit);
+}
+function normalizeSource(source) {
+    return resolve(source);
+}
+function contains(packageRoot, source) {
+    const path = relative(packageRoot, source);
+    return path === '' || (!path.startsWith('..') && !isAbsolute(path));
+}
+function sameRecord(left, right) {
+    return (left.role === right.role &&
+        left.owner === right.owner &&
+        left.capability === right.capability &&
+        left.feature === right.feature);
+}