@agentxm/workspace-state 0.28.4-bootstrap.0

package/dist/src/workspace/read-model/extensions/projection.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Shared projection helper: composes installed/active/unmanaged from
+ * declared/resolved/actual plus the installed-pack set.
+ *
+ * Per the projection invariant in the workspace read-model design (Decision 7):
+ *
+ * ```ts
+ * direct = declared.map(withInstallationOrigin("direct"));
+ * implicit = installedPacks
+ *   .flatMap(p => p.members)
+ *   .filter(notDeclaredByName) // direct (incl. disabled) wins
+ *   .map(withInstallationOrigin("pack-member"));
+ * installed = direct + implicit;
+ * active = installed.filter(activation === "enabled");
+ * unmanaged = actual
+ *   .filter(notClaimedByInstalled)
+ *   .filter(notClaimedBySubjectPolicy);
+ * ```
+ *
+ * The helper owns:
+ * - direct-over-pack precedence;
+ * - disabled-direct still claims actual occurrences (excluded from active and
+ *   from unmanaged);
+ * - actual-occurrence attachment via `policy.attachActualToInstalled`;
+ * - orphaned-resolved diagnostics — resolved entries with no direct or
+ *   pack-member home publish a warning;
+ * - deterministic name-sorted ordering.
+ *
+ * The helper does NOT own subject row shape or subject policy. Both come in as
+ * parameters via `SubjectPolicy<...>`.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type { Diagnostics, Warning } from "../diagnostics.js";
+import type { LockfileReadError, SettingsReadError } from "../errors.js";
+import type { ActivationState, InstallationOrigin, InstalledPackRef } from "../types.js";
+import { type RowWithKey } from "./indexByName.js";
+/**
+ * One entry within a subject's `declared` payload. The shape is opaque to the
+ * helper; the policy callbacks bridge to subject internals.
+ */
+export type TDeclaredEntry<TDeclared> = TDeclared extends ReadonlyArray<infer E> ? E : TDeclared;
+/** One entry within a subject's `resolved` payload. */
+export type TResolvedEntry<TResolved> = TResolved extends ReadonlyArray<infer E> ? E : TResolved;
+/** One actual occurrence within a subject's `actual` payload. */
+export type TActualEntry<TActual> = TActual extends ReadonlyArray<infer E> ? E : TActual;
+/**
+ * Subject-specific policy callbacks the projection helper requires.
+ */
+export interface SubjectPolicy<TDeclared, TResolved, TActual, TPackMember, TInstalled, TUnmanaged> {
+    /** Iterate the subject's declared entries from a decoded `declared` payload. */
+    readonly declaredEntries: (declared: TDeclared) => ReadonlyArray<TDeclaredEntry<TDeclared>>;
+    /** Extract the subject name from a declared entry. */
+    readonly declaredName: (entry: TDeclaredEntry<TDeclared>) => string;
+    /**
+     * Activation state derived from a declared entry.
+     */
+    readonly declaredActivation: (entry: TDeclaredEntry<TDeclared>) => ActivationState;
+    /** Iterate the subject's resolved entries from a decoded `resolved` payload. */
+    readonly resolvedEntries: (resolved: TResolved) => ReadonlyArray<TResolvedEntry<TResolved>>;
+    /** Extract the subject name from a resolved entry. */
+    readonly resolvedName: (entry: TResolvedEntry<TResolved>) => string;
+    /** Iterate the subject's actual occurrences from an `actual` payload. */
+    readonly actualEntries: (actual: TActual) => ReadonlyArray<TActualEntry<TActual>>;
+    /** Extract the subject name from an actual occurrence. */
+    readonly actualName: (entry: TActualEntry<TActual>) => string;
+    /** Extract the subject name from a pack-member entry. */
+    readonly packMemberName: (member: TPackMember) => string;
+    /** Activation state for a pack-member installed row. */
+    readonly packMemberActivation: (member: TPackMember) => ActivationState;
+    /** Filter actual occurrences to those that match a given installed name. */
+    readonly attachActualToInstalled: (name: string, actual: ReadonlyArray<TActualEntry<TActual>>) => ReadonlyArray<TActualEntry<TActual>>;
+    /**
+     * Subject-policy filter for unmanaged actual occurrences. Returns `true` if
+     * the occurrence is NOT claimed by subject-specific policy.
+     */
+    readonly notClaimedBySubjectPolicy: (entry: TActualEntry<TActual>) => boolean;
+    /** Build a subject installed row from the assembled facts. */
+    readonly buildInstalledRow: (input: BuildInstalledRowInput<TDeclared, TResolved, TActual, TPackMember>) => TInstalled;
+    /** Build a subject unmanaged row from one actual occurrence. */
+    readonly buildUnmanagedRow: (entry: TActualEntry<TActual>) => TUnmanaged;
+    /** Build the orphan-resolved warning published when a resolved entry has no home. */
+    readonly resolvedOrphanWarning: (name: string) => Warning;
+}
+/**
+ * Input passed to `buildInstalledRow`. Carries everything the subject needs
+ * to construct its installed row.
+ */
+export interface BuildInstalledRowInput<TDeclared, TResolved, TActual, TPackMember> {
+    readonly name: string;
+    readonly installationOrigin: InstallationOrigin<TDeclaredEntry<TDeclared>, TPackMember>;
+    readonly activation: ActivationState;
+    readonly resolved: Option.Option<TResolvedEntry<TResolved>>;
+    readonly actual: ReadonlyArray<TActualEntry<TActual>>;
+    readonly providingPacks: ReadonlyArray<InstalledPackRef>;
+}
+export interface ProjectInstalledExtensionsInput<TDeclared, TResolved, TActual, TPack, TPackMember, TInstalled, TUnmanaged> {
+    readonly declared: Effect.Effect<Option.Option<TDeclared>, SettingsReadError>;
+    readonly resolved: Effect.Effect<Option.Option<TResolved>, LockfileReadError>;
+    readonly actual: Effect.Effect<TActual>;
+    readonly installedPacks: Effect.Effect<ReadonlyArray<TPack>, SettingsReadError | LockfileReadError>;
+    readonly packMembers: (pack: TPack) => ReadonlyArray<TPackMember>;
+    readonly packRef: (pack: TPack) => InstalledPackRef;
+    readonly policy: SubjectPolicy<TDeclared, TResolved, TActual, TPackMember, TInstalled, TUnmanaged>;
+    readonly diagnostics: Diagnostics;
+}
+export interface ProjectInstalledExtensionsOutput<TInstalled, TUnmanaged> {
+    readonly installed: ReadonlyArray<TInstalled>;
+    readonly active: ReadonlyArray<TInstalled>;
+    readonly unmanaged: ReadonlyArray<TUnmanaged>;
+}
+export declare const makeProjectedSubjectCells: <TDeclaredEntry extends {
+    readonly name: string;
+}, TDeclared extends ReadonlyArray<TDeclaredEntry>, TResolved, TActual, TInstalled extends RowWithKey, TUnmanaged>(args: {
+    readonly declared: Effect.Effect<Option.Option<TDeclared>, SettingsReadError>;
+    readonly resolved: Effect.Effect<Option.Option<TResolved>, LockfileReadError>;
+    readonly actual: Effect.Effect<TActual>;
+    readonly project: Effect.Effect<ProjectInstalledExtensionsOutput<TInstalled, TUnmanaged>, SettingsReadError | LockfileReadError>;
+}) => {
+    declared: Effect.Effect<Option.Option<TDeclared>, SettingsReadError, never>;
+    resolved: Effect.Effect<Option.Option<TResolved>, LockfileReadError, never>;
+    actual: Effect.Effect<TActual, never, never>;
+    installed: Effect.Effect<readonly TInstalled[], SettingsReadError | LockfileReadError, never>;
+    byName: (name: string) => Effect.Effect<Option.Option<TInstalled>, SettingsReadError | LockfileReadError, never>;
+    declaredByName: (name: string) => Effect.Effect<Option.Option<Exclude<TDeclaredEntry, undefined>>, SettingsReadError, never>;
+    active: Effect.Effect<readonly TInstalled[], SettingsReadError | LockfileReadError, never>;
+    unmanaged: Effect.Effect<readonly TUnmanaged[], SettingsReadError | LockfileReadError, never>;
+};
+/**
+ * Compose installed, active, and unmanaged rows from declared/resolved/actual
+ * plus the installed-pack set, per the projection invariant.
+ *
+ * Source-read failures propagate so invalid persisted authority is never
+ * treated as absent.
+ */
+export declare const projectInstalledExtensions: <TDeclared, TResolved, TActual, TPack, TPackMember, TInstalled, TUnmanaged>(input: ProjectInstalledExtensionsInput<TDeclared, TResolved, TActual, TPack, TPackMember, TInstalled, TUnmanaged>) => Effect.Effect<ProjectInstalledExtensionsOutput<TInstalled, TUnmanaged>, SettingsReadError | LockfileReadError>;
+//# sourceMappingURL=projection.d.ts.map

package/dist/src/workspace/read-model/extensions/projection.js

@@ -0,0 +1,180 @@
+/**
+ * Shared projection helper: composes installed/active/unmanaged from
+ * declared/resolved/actual plus the installed-pack set.
+ *
+ * Per the projection invariant in the workspace read-model design (Decision 7):
+ *
+ * ```ts
+ * direct = declared.map(withInstallationOrigin("direct"));
+ * implicit = installedPacks
+ *   .flatMap(p => p.members)
+ *   .filter(notDeclaredByName) // direct (incl. disabled) wins
+ *   .map(withInstallationOrigin("pack-member"));
+ * installed = direct + implicit;
+ * active = installed.filter(activation === "enabled");
+ * unmanaged = actual
+ *   .filter(notClaimedByInstalled)
+ *   .filter(notClaimedBySubjectPolicy);
+ * ```
+ *
+ * The helper owns:
+ * - direct-over-pack precedence;
+ * - disabled-direct still claims actual occurrences (excluded from active and
+ *   from unmanaged);
+ * - actual-occurrence attachment via `policy.attachActualToInstalled`;
+ * - orphaned-resolved diagnostics — resolved entries with no direct or
+ *   pack-member home publish a warning;
+ * - deterministic name-sorted ordering.
+ *
+ * The helper does NOT own subject row shape or subject policy. Both come in as
+ * parameters via `SubjectPolicy<...>`.
+ */
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { findByName } from "./indexByName.js";
+export const makeProjectedSubjectCells = (args) => ({
+    declared: args.declared,
+    resolved: args.resolved,
+    actual: args.actual,
+    installed: args.project.pipe(Effect.map((out) => out.installed)),
+    byName: (name) => args.project.pipe(Effect.map((out) => findByName(out.installed, name))),
+    declaredByName: (name) => args.declared.pipe(Effect.map((opt) => Option.flatMap(opt, (rows) => Option.fromUndefinedOr(rows.find((row) => row.name === name))))),
+    active: args.project.pipe(Effect.map((out) => out.active)),
+    unmanaged: args.project.pipe(Effect.map((out) => out.unmanaged)),
+});
+// ---------------------------------------------------------------------------
+// Public helper
+// ---------------------------------------------------------------------------
+/**
+ * Compose installed, active, and unmanaged rows from declared/resolved/actual
+ * plus the installed-pack set, per the projection invariant.
+ *
+ * Source-read failures propagate so invalid persisted authority is never
+ * treated as absent.
+ */
+export const projectInstalledExtensions = (input) => Effect.gen(function* () {
+    const { declared, resolved, actual, installedPacks, packMembers, packRef, policy, diagnostics, } = input;
+    // 1. Read the three layers + installed packs. Invalid persisted authority
+    //    fails the projection instead of being treated as absent.
+    const declaredOpt = yield* declared;
+    const resolvedOpt = yield* resolved;
+    const actualPayload = yield* actual;
+    const packs = yield* installedPacks;
+    // 2. Iterate raw evidence into per-name lookups using first-wins
+    //    deduplication. `dedupeFirstByName` builds an immutable Map keyed by
+    //    the policy-derived name; subsequent entries with the same name are
+    //    dropped, so the projection stays deterministic.
+    const emptyDeclared = [];
+    const emptyResolved = [];
+    const declaredEntries = Option.match(declaredOpt, {
+        onNone: () => emptyDeclared,
+        onSome: (d) => policy.declaredEntries(d),
+    });
+    const resolvedEntries = Option.match(resolvedOpt, {
+        onNone: () => emptyResolved,
+        onSome: (r) => policy.resolvedEntries(r),
+    });
+    const actualEntries = policy.actualEntries(actualPayload);
+    const declaredByName = dedupeFirstByName(declaredEntries, policy.declaredName);
+    const resolvedByName = dedupeFirstByName(resolvedEntries, policy.resolvedName);
+    const packMemberPairs = packs.flatMap((pack) => {
+        const ref = packRef(pack);
+        return packMembers(pack).map((member) => [member, ref]);
+    });
+    const memberByName = packMemberPairs.reduce((acc, [member, ref]) => {
+        const name = policy.packMemberName(member);
+        const existing = acc.get(name);
+        const next = new Map(acc);
+        if (existing === undefined) {
+            next.set(name, { member, pack: ref, providingPacks: [ref] });
+        }
+        else {
+            next.set(name, {
+                member: existing.member,
+                pack: existing.pack,
+                providingPacks: [...existing.providingPacks, ref],
+            });
+        }
+        return next;
+    }, new Map());
+    const direct = Array.getSomes(Array.fromIterable(declaredByName.entries()).map(([name, entry]) => {
+        const activation = policy.declaredActivation(entry);
+        const memberState = memberByName.get(name);
+        const providingPacks = memberState === undefined ? [] : memberState.providingPacks;
+        const attached = policy.attachActualToInstalled(name, actualEntries);
+        const row = policy.buildInstalledRow({
+            name,
+            installationOrigin: { _tag: "direct", declared: entry },
+            activation,
+            resolved: Option.fromUndefinedOr(resolvedByName.get(name)),
+            actual: attached,
+            providingPacks,
+        });
+        return Option.some({ name, row, activation });
+    }));
+    // 5. Implicit pack-member rows: skip names already declared (direct wins,
+    //    including disabled).
+    const implicit = Array.getSomes(Array.fromIterable(memberByName.entries()).map(([name, state]) => {
+        if (declaredByName.has(name))
+            return Option.none(); // direct wins
+        const activation = policy.packMemberActivation(state.member);
+        const attached = policy.attachActualToInstalled(name, actualEntries);
+        const row = policy.buildInstalledRow({
+            name,
+            installationOrigin: {
+                _tag: "pack-member",
+                member: state.member,
+                pack: state.pack,
+            },
+            activation,
+            resolved: Option.fromUndefinedOr(resolvedByName.get(name)),
+            actual: attached,
+            providingPacks: state.providingPacks,
+        });
+        return Option.some({ name, row, activation });
+    }));
+    // 6. Sort by name for deterministic ordering.
+    const installedNamed = [...direct, ...implicit].sort((a, b) => a.name.localeCompare(b.name));
+    const installedNames = new Set(installedNamed.map((r) => r.name));
+    const installed = installedNamed.map((r) => r.row);
+    const active = installedNamed
+        .filter((r) => r.activation === "enabled")
+        .map((r) => r.row);
+    // 7. Orphaned-resolved diagnostics: any resolved entry whose name is
+    //    neither declared nor present as a pack-member. Collect orphan names
+    //    first, then publish sequentially via Effect.forEach to keep the
+    //    diagnostics buffer in deterministic order.
+    const orphanNames = Array.fromIterable(resolvedByName.keys()).filter((name) => !declaredByName.has(name) && !memberByName.has(name));
+    yield* Effect.forEach(orphanNames, (name) => diagnostics.append(policy.resolvedOrphanWarning(name)), { discard: true });
+    // 8. Unmanaged: actual occurrences not claimed by an installed row and
+    //    passing subject policy.
+    const unmanaged = Array.getSomes(actualEntries.map((entry) => {
+        const name = policy.actualName(entry);
+        if (installedNames.has(name))
+            return Option.none();
+        if (!policy.notClaimedBySubjectPolicy(entry))
+            return Option.none();
+        return Option.some(policy.buildUnmanagedRow(entry));
+    }));
+    return {
+        installed,
+        active,
+        unmanaged,
+    };
+});
+/**
+ * Build a name-indexed read-only map, keeping the first occurrence per name.
+ * Subsequent entries with the same name are dropped; the original input order
+ * determines which one wins. Pure helper used to dedupe declared/resolved
+ * entry arrays.
+ */
+const dedupeFirstByName = (entries, nameOf) => entries.reduce((acc, entry) => {
+    const name = nameOf(entry);
+    if (acc.has(name))
+        return acc;
+    const next = new Map(acc);
+    next.set(name, entry);
+    return next;
+}, new Map());
+//# sourceMappingURL=projection.js.map

package/dist/src/workspace/read-model/extensions/rule.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Rule subject module: declared/resolved/actual payloads, scanner composition,
+ * and projections via the shared helper.
+ *
+ * Rules have no `axm.json` entry shape and no `axm-lock.yaml` entry
+ * shape in v1. Actual occurrences come from the canonical-extensions
+ * scanner (`type === "rule"`); the agent-dir scanner emits no rule
+ * occurrences in the v1 `AgentRegistry`, but the subject module accepts an
+ * agent-dir scanner input so future agents can register rule directories
+ * without further changes here.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type { AgentId } from "@agentxm/extension-model/unstable/agents/types";
+import { type ExtensionName } from "@agentxm/extension-model/unstable/extensions/common";
+import type { Lockfile, RuleLockEntry } from "../../../lockfile/schema.js";
+import type { RuleEntry, Settings } from "../../../settings/schema.js";
+import type { Diagnostics } from "../diagnostics.js";
+import type { LockfileReadError, SettingsReadError } from "../errors.js";
+import type { CanonicalExtensionOccurrence } from "../scanners/types.js";
+import type { ActivationState, ExtensionKey, InstallationOrigin, InstalledPackRef, Scope } from "../types.js";
+export type RuleDetectionOrigin = {
+    readonly _tag: "canonical-axm-rule";
+} | {
+    readonly _tag: "external-axm-rule";
+} | {
+    readonly _tag: "agent-rule-dir";
+    readonly agentId: AgentId;
+};
+export interface DeclaredRule {
+    readonly name: ExtensionName;
+    readonly entry: RuleEntry;
+}
+export type DeclaredRules = ReadonlyArray<DeclaredRule>;
+export interface ResolvedRule {
+    readonly name: ExtensionName;
+    readonly lockEntry: RuleLockEntry;
+}
+export type ResolvedRules = ReadonlyArray<ResolvedRule>;
+export interface ActualRule {
+    readonly key: ExtensionKey<"rule">;
+    readonly origin: RuleDetectionOrigin;
+    readonly contentRoot: string;
+    readonly packageRoot: string | null;
+}
+export type ActualRules = ReadonlyArray<ActualRule>;
+export interface RulePackMember {
+    readonly name: ExtensionName;
+    readonly providingPack: InstalledPackRef;
+}
+export interface InstalledRule {
+    readonly key: ExtensionKey<"rule">;
+    readonly installationOrigin: InstallationOrigin<DeclaredRule, RulePackMember>;
+    readonly activation: ActivationState;
+    readonly resolved: Option.Option<ResolvedRule>;
+    readonly actual: ReadonlyArray<ActualRule>;
+    readonly providingPacks: ReadonlyArray<InstalledPackRef>;
+}
+export interface UnmanagedRule {
+    readonly key: ExtensionKey<"rule">;
+    readonly actual: ActualRule;
+}
+/**
+ * Rule scanners. v1 ships a canonical scanner only; the v1 `AgentRegistry`
+ * does not register rule directories, so there is no agent-dir rule input.
+ * If a future agent registers a rule directory, this scanner record gains an
+ * `agentDir` field and the subject module wires through `agent-rule-dir`
+ * origins.
+ */
+export interface RuleScanners {
+    readonly canonical: Effect.Effect<ReadonlyArray<CanonicalExtensionOccurrence>>;
+}
+export interface RuleScopedLoaders {
+    readonly settings: Effect.Effect<Option.Option<Settings>, SettingsReadError>;
+    readonly lockfile: Effect.Effect<Option.Option<Lockfile>, LockfileReadError>;
+}
+export interface InstalledPackForRules {
+    readonly ref: InstalledPackRef;
+    readonly rules: ReadonlyArray<RulePackMember>;
+}
+export interface RuleExtensionsApiDeps {
+    readonly scope: Scope;
+    readonly loaders: RuleScopedLoaders;
+    readonly scanners: RuleScanners;
+    readonly installedPacks: Effect.Effect<ReadonlyArray<InstalledPackForRules>, SettingsReadError | LockfileReadError>;
+    readonly diagnostics: Diagnostics;
+}
+export interface RuleExtensionsApi {
+    readonly declared: Effect.Effect<Option.Option<DeclaredRules>, SettingsReadError>;
+    readonly resolved: Effect.Effect<Option.Option<ResolvedRules>, LockfileReadError>;
+    readonly actual: Effect.Effect<ActualRules>;
+    readonly installed: Effect.Effect<ReadonlyArray<InstalledRule>, SettingsReadError | LockfileReadError>;
+    readonly byName: (name: string) => Effect.Effect<Option.Option<InstalledRule>, SettingsReadError | LockfileReadError>;
+    readonly declaredByName: (name: string) => Effect.Effect<Option.Option<DeclaredRule>, SettingsReadError>;
+    readonly active: Effect.Effect<ReadonlyArray<InstalledRule>, SettingsReadError | LockfileReadError>;
+    readonly unmanaged: Effect.Effect<ReadonlyArray<UnmanagedRule>, SettingsReadError | LockfileReadError>;
+}
+/**
+ * Build the rule subject API. Returns an `Effect` because the projection
+ * cell is wrapped in `Effect.cached` so the four derived cells share one
+ * in-flight execution per scope, mirroring `state.ts`.
+ */
+export declare const makeRuleExtensionsApi: (deps: RuleExtensionsApiDeps) => Effect.Effect<RuleExtensionsApi>;
+//# sourceMappingURL=rule.d.ts.map

package/dist/src/workspace/read-model/extensions/rule.js

@@ -0,0 +1,113 @@
+/**
+ * Rule subject module: declared/resolved/actual payloads, scanner composition,
+ * and projections via the shared helper.
+ *
+ * Rules have no `axm.json` entry shape and no `axm-lock.yaml` entry
+ * shape in v1. Actual occurrences come from the canonical-extensions
+ * scanner (`type === "rule"`); the agent-dir scanner emits no rule
+ * occurrences in the v1 `AgentRegistry`, but the subject module accepts an
+ * agent-dir scanner input so future agents can register rule directories
+ * without further changes here.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { decodeExtensionNameSync, } from "@agentxm/extension-model/unstable/extensions/common";
+import { filterMapOccurrences } from "./actual-helpers.js";
+import { canonicalAxmPackageRoot } from "./package-root.js";
+import { makeProjectedSubjectCells, projectInstalledExtensions, } from "./projection.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const canonicalToActual = (occ, scope) => {
+    const isExternal = occ.origin === "external-axm";
+    const packageRoot = canonicalAxmPackageRoot(occ);
+    return {
+        key: { scope, type: "rule", name: occ.name },
+        origin: isExternal ? { _tag: "external-axm-rule" } : { _tag: "canonical-axm-rule" },
+        contentRoot: occ.contentLocation,
+        packageRoot,
+    };
+};
+const declaredFromSettings = (settings) => {
+    if (settings.rules === undefined)
+        return [];
+    return Object.entries(settings.rules).map(([name, entry]) => ({
+        name: decodeExtensionNameSync(name),
+        entry,
+    }));
+};
+const resolvedFromLockfile = (lockfile) => {
+    if (lockfile.rules === undefined)
+        return [];
+    return Object.entries(lockfile.rules).map(([name, lockEntry]) => ({
+        name: decodeExtensionNameSync(name),
+        lockEntry,
+    }));
+};
+const orphanResolvedWarning = (name) => ({
+    source: "lockfile",
+    message: `rule: lockfile entry "${name}" has no matching declared or pack-member home`,
+    code: "orphan-resolved",
+});
+const rulePolicy = (scope) => ({
+    declaredEntries: (d) => d,
+    declaredName: (entry) => entry.name,
+    declaredActivation: (entry) => (entry.entry.enabled === false ? "disabled" : "enabled"),
+    resolvedEntries: (r) => r,
+    resolvedName: (entry) => entry.name,
+    actualEntries: (a) => a,
+    actualName: (e) => e.key.name,
+    packMemberName: (m) => m.name,
+    packMemberActivation: () => "enabled",
+    attachActualToInstalled: (name, actual) => actual.filter((a) => a.key.name === name),
+    notClaimedBySubjectPolicy: () => true,
+    buildInstalledRow: (input) => ({
+        key: { scope, type: "rule", name: input.name },
+        installationOrigin: input.installationOrigin,
+        activation: input.activation,
+        resolved: input.resolved,
+        actual: input.actual,
+        providingPacks: input.providingPacks,
+    }),
+    buildUnmanagedRow: (entry) => ({
+        key: { scope, type: "rule", name: entry.key.name },
+        actual: entry,
+    }),
+    resolvedOrphanWarning: orphanResolvedWarning,
+});
+/**
+ * Build the rule subject API. Returns an `Effect` because the projection
+ * cell is wrapped in `Effect.cached` so the four derived cells share one
+ * in-flight execution per scope, mirroring `state.ts`.
+ */
+export const makeRuleExtensionsApi = (deps) => Effect.gen(function* () {
+    const { scope, scanners, diagnostics } = deps;
+    const declared = deps.loaders.settings.pipe(Effect.map((opt) => Option.map(opt, declaredFromSettings)));
+    const resolved = deps.loaders.lockfile.pipe(Effect.map((opt) => Option.map(opt, resolvedFromLockfile)));
+    const actual = Effect.gen(function* () {
+        const canonical = yield* scanners.canonical;
+        return filterMapOccurrences(canonical, "rule", (occ) => canonicalToActual(occ, scope));
+    });
+    const project = yield* Effect.cached(projectInstalledExtensions({
+        declared,
+        resolved,
+        actual,
+        installedPacks: deps.installedPacks,
+        packMembers: (pack) => pack.rules,
+        packRef: (pack) => pack.ref,
+        policy: rulePolicy(scope),
+        diagnostics,
+    }));
+    return {
+        ...makeProjectedSubjectCells({
+            declared,
+            resolved,
+            actual,
+            project,
+        }),
+        declared,
+        resolved,
+        actual,
+    };
+});
+//# sourceMappingURL=rule.js.map