@ericsanchezok/synergy-util 3.0.24 → 3.1.0

package/dist/capability.js

@@ -27,12 +27,6 @@ export const SYNERGY_CAPABILITY_DETAILS = {
         description: "Can operate observed native application windows using background input in Full Access mode.",
         nonBypassable: true,
     },
-    shell_read: {
-        category: "runtime",
-        severity: "low",
-        title: "Run read-only shell commands",
-        description: "Can run shell commands classified as read-only.",
-    },
     shell: {
         category: "runtime",
         severity: "medium",
@@ -51,13 +45,6 @@ export const SYNERGY_CAPABILITY_DETAILS = {
         title: "Run remote-write shell commands",
         description: "Can modify existing remote state outside ordinary branch/PR publication workflows.",
     },
-    shell_remote_execute: {
-        category: "runtime",
-        severity: "high",
-        title: "Execute commands on remote host",
-        description: "Can run bash/process commands on a remote Synergy Link host.",
-        nonBypassable: true,
-    },
     shell_remote_publish: {
         category: "runtime",
         severity: "medium",
@@ -68,14 +55,14 @@ export const SYNERGY_CAPABILITY_DETAILS = {
         category: "runtime",
         severity: "high",
         title: "Run destructive shell commands",
-        description: "Can run commands that may delete, overwrite, or rewrite important local state.",
+        description: "Can run commands that the OS sandbox cannot express: host-level or system-location destruction, irreversible local history loss, and privilege escalation.",
         nonBypassable: true,
     },
     shell_hardline: {
         category: "runtime",
         severity: "high",
         title: "Run forbidden shell commands",
-        description: "Matches shell commands that Synergy treats as a hard safety boundary.",
+        description: "Matches the machine-wide commands Synergy refuses under every profile: filesystem-root and home destruction, filesystem-format and power tools, fork bombs, and raw-device writes.",
         nonBypassable: true,
     },
     file_write: {
@@ -315,10 +302,8 @@ export const SYNERGY_CAPABILITY_DETAILS = {
 export const SYNERGY_PROFILE_CAPABILITIES = [
     "file_read",
     "file_write",
-    "shell_read",
     "shell",
     "shell_branch_mutation",
-    "shell_remote_execute",
     "shell_remote_publish",
     "shell_remote_write",
     "shell_destructive",
@@ -371,6 +356,7 @@ export const SYNERGY_PERMISSION_CAPABILITY = {
     edit: "file_write",
     write: "file_write",
     revise_file: "file_write",
+    apply_patch: "file_write",
     resolve_conflicts: "file_write",
     save_file: "file_write",
     bash: "shell",
@@ -381,7 +367,6 @@ export const SYNERGY_PERMISSION_CAPABILITY = {
     scan_document: "file_read",
     look_at: "file_read",
     view_image: "file_read",
-    attach: "file_read",
     ast_grep: "file_read",
     lsp: "file_read",
     dagread: "file_read",
@@ -390,7 +375,7 @@ export const SYNERGY_PERMISSION_CAPABILITY = {
     task_output: "file_read",
     question: "file_read",
     skill: "file_read",
-    render: "file_read",
+    render: "session_state",
     agenda_list: "file_read",
     agenda_logs: "file_read",
     session_list: "file_read",
@@ -409,6 +394,7 @@ export const SYNERGY_PERMISSION_CAPABILITY = {
     doom_loop: "session_state",
     worktree_enter: "file_write",
     worktree_leave: "file_write",
+    worktree_archive: "file_write",
     agent_config: "config:write",
     session_data: "session_data",
     workspace_data: "workspace_data",

package/dist/cli-command.d.ts

@@ -0,0 +1,12 @@
+import type { CommandModule } from "yargs";
+export type { CommandModule } from "yargs";
+export interface CommandEntry {
+    command: string | string[];
+    describe: string;
+    storage?: "maintenance" | ((positionals: readonly (string | number)[]) => "maintenance" | undefined);
+    load(): Promise<CommandModule>;
+}
+type WithDoubleDash<T> = T & {
+    "--"?: string[];
+};
+export declare function cmd<T, U>(input: CommandModule<T, WithDoubleDash<U>>): CommandModule<T, WithDoubleDash<U>>;

package/dist/cli-command.js

@@ -0,0 +1,3 @@
+export function cmd(input) {
+    return input;
+}

package/dist/encode.d.ts

@@ -1,4 +1,7 @@
 export declare function base64Encode(value: string): string;
+/** RFC 4648 standard base64 (with padding) for opaque labels like data: URLs;
+ *  unlike base64Encode this output is safe for strict atob decoders. */
+export declare function base64EncodeStandard(value: string): string;
 export declare function base64Decode(value: string): string;
 export declare function hash(content: string, algorithm?: string): Promise<string>;
 export declare function checksum(content: string): string | undefined;

package/dist/encode.js

@@ -3,6 +3,13 @@ export function base64Encode(value) {
     const binary = Array.from(bytes, (b) => String.fromCharCode(b)).join("");
     return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
 }
+/** RFC 4648 standard base64 (with padding) for opaque labels like data: URLs;
+ *  unlike base64Encode this output is safe for strict atob decoders. */
+export function base64EncodeStandard(value) {
+    const bytes = new TextEncoder().encode(value);
+    const binary = Array.from(bytes, (b) => String.fromCharCode(b)).join("");
+    return btoa(binary);
+}
 export function base64Decode(value) {
     const binary = atob(value.replace(/-/g, "+").replace(/_/g, "/"));
     const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));

package/dist/error.d.ts

@@ -1,4 +1,16 @@
 import z from "zod";
+export interface NamedErrorInstance<Name extends string, Data extends z.core.$ZodType> extends NamedError {
+    readonly name: Name;
+    readonly data: z.input<Data>;
+    schema(): z.ZodObject<{
+        name: z.ZodLiteral<Name>;
+        data: Data;
+    }>;
+    toObject(): {
+        name: Name;
+        data: z.input<Data>;
+    };
+}
 export declare abstract class NamedError extends Error {
     abstract schema(): z.core.$ZodType;
     abstract toObject(): {
@@ -7,6 +19,7 @@ export declare abstract class NamedError extends Error {
     };
     static create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): {
         new (data: z.input<Data>, options?: ErrorOptions): {
+            cause?: unknown;
             readonly name: Name;
             readonly data: z.core.input<Data>;
             schema(): z.ZodObject<{
@@ -19,18 +32,20 @@ export declare abstract class NamedError extends Error {
             };
             message: string;
             stack?: string;
-            cause?: unknown;
         };
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
         readonly Schema: z.ZodObject<{
             name: z.ZodLiteral<Name>;
             data: Data;
         }, z.core.$strip>;
-        isInstance(input: any): input is InstanceType</*elided*/ any>;
+        isInstance(input: any): input is NamedErrorInstance<Name, Data>;
         create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): /*elided*/ any;
         readonly Unknown: {
             new (data: {
                 message: string;
             }, options?: ErrorOptions): {
+                cause?: unknown;
                 readonly name: "UnknownError";
                 readonly data: {
                     message: string;
@@ -49,53 +64,35 @@ export declare abstract class NamedError extends Error {
                 };
                 message: string;
                 stack?: string;
-                cause?: unknown;
             };
+            isError(error: unknown): error is Error;
+            isError(value: unknown): value is Error;
             readonly Schema: z.ZodObject<{
                 name: z.ZodLiteral<"UnknownError">;
                 data: z.ZodObject<{
                     message: z.ZodString;
                 }, z.core.$strip>;
             }, z.core.$strip>;
-            isInstance(input: any): input is {
-                readonly name: "UnknownError";
-                readonly data: {
-                    message: string;
-                };
-                schema(): z.ZodObject<{
-                    name: z.ZodLiteral<"UnknownError">;
-                    data: z.ZodObject<{
-                        message: z.ZodString;
-                    }, z.core.$strip>;
-                }, z.core.$strip>;
-                toObject(): {
-                    name: "UnknownError";
-                    data: {
-                        message: string;
-                    };
-                };
-                message: string;
-                stack?: string;
-                cause?: unknown;
-            };
+            isInstance(input: any): input is NamedErrorInstance<"UnknownError", z.ZodObject<{
+                message: z.ZodString;
+            }, z.core.$strip>>;
             create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): /*elided*/ any;
             readonly Unknown: /*elided*/ any;
-            isError(value: unknown): value is Error;
             captureStackTrace(targetObject: object, constructorOpt?: Function): void;
             captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
             stackTraceLimit: number;
-            prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
         };
-        isError(value: unknown): value is Error;
         captureStackTrace(targetObject: object, constructorOpt?: Function): void;
         captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
         stackTraceLimit: number;
-        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
     };
     static readonly Unknown: {
         new (data: {
             message: string;
         }, options?: ErrorOptions): {
+            cause?: unknown;
             readonly name: "UnknownError";
             readonly data: {
                 message: string;
@@ -114,37 +111,21 @@ export declare abstract class NamedError extends Error {
             };
             message: string;
             stack?: string;
-            cause?: unknown;
         };
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
         readonly Schema: z.ZodObject<{
             name: z.ZodLiteral<"UnknownError">;
             data: z.ZodObject<{
                 message: z.ZodString;
             }, z.core.$strip>;
         }, z.core.$strip>;
-        isInstance(input: any): input is {
-            readonly name: "UnknownError";
-            readonly data: {
-                message: string;
-            };
-            schema(): z.ZodObject<{
-                name: z.ZodLiteral<"UnknownError">;
-                data: z.ZodObject<{
-                    message: z.ZodString;
-                }, z.core.$strip>;
-            }, z.core.$strip>;
-            toObject(): {
-                name: "UnknownError";
-                data: {
-                    message: string;
-                };
-            };
-            message: string;
-            stack?: string;
-            cause?: unknown;
-        };
+        isInstance(input: any): input is NamedErrorInstance<"UnknownError", z.ZodObject<{
+            message: z.ZodString;
+        }, z.core.$strip>>;
         create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): {
             new (data: z.input<Data>, options?: ErrorOptions): {
+                cause?: unknown;
                 readonly name: Name;
                 readonly data: z.core.input<Data>;
                 schema(): z.ZodObject<{
@@ -157,26 +138,25 @@ export declare abstract class NamedError extends Error {
                 };
                 message: string;
                 stack?: string;
-                cause?: unknown;
             };
+            isError(error: unknown): error is Error;
+            isError(value: unknown): value is Error;
             readonly Schema: z.ZodObject<{
                 name: z.ZodLiteral<Name>;
                 data: Data;
             }, z.core.$strip>;
-            isInstance(input: any): input is InstanceType</*elided*/ any>;
+            isInstance(input: any): input is NamedErrorInstance<Name, Data>;
             create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): /*elided*/ any;
             readonly Unknown: /*elided*/ any;
-            isError(value: unknown): value is Error;
             captureStackTrace(targetObject: object, constructorOpt?: Function): void;
             captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
             stackTraceLimit: number;
-            prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
         };
         readonly Unknown: /*elided*/ any;
-        isError(value: unknown): value is Error;
         captureStackTrace(targetObject: object, constructorOpt?: Function): void;
         captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
         stackTraceLimit: number;
-        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
     };
 }

package/dist/feature-config.d.ts

@@ -0,0 +1,4 @@
+import { FeaturePreferences } from "./features";
+export declare const FEATURE_CONFIG_FILENAME = "140-features.jsonc";
+export declare function parseFeatureConfig(text: string): FeaturePreferences;
+export declare function readFeaturePreferences(configDirectory: string): Promise<FeaturePreferences>;

package/dist/feature-config.js

@@ -0,0 +1,23 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { parse } from "jsonc-parser";
+import { z } from "zod";
+import { FeaturePreferences } from "./features";
+export const FEATURE_CONFIG_FILENAME = "140-features.jsonc";
+const Document = z.object({ $schema: z.string().optional(), features: FeaturePreferences.optional() }).strict();
+export function parseFeatureConfig(text) {
+    const errors = [];
+    const value = parse(text, errors, { allowTrailingComma: true });
+    if (errors.length)
+        throw new Error("Invalid experimental feature configuration");
+    return Document.parse(value).features ?? { optIn: [] };
+}
+export async function readFeaturePreferences(configDirectory) {
+    const filename = path.join(configDirectory, "synergy.d", FEATURE_CONFIG_FILENAME);
+    const text = await readFile(filename, "utf8").catch((error) => {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    return text === undefined ? { optIn: [] } : parseFeatureConfig(text);
+}

package/dist/features.d.ts

@@ -0,0 +1,134 @@
+import { z } from "zod";
+export declare const FeatureDefinition: z.ZodObject<{
+    id: z.ZodString;
+    owner: z.ZodString;
+    maturity: z.ZodEnum<{
+        experimental: "experimental";
+        stable: "stable";
+    }>;
+    activation: z.ZodEnum<{
+        live: "live";
+        restart: "restart";
+    }>;
+    name: z.ZodString;
+    description: z.ZodString;
+    component: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type FeatureDefinition = z.infer<typeof FeatureDefinition>;
+export declare const ComponentFeatures: z.ZodObject<{
+    kind: z.ZodEnum<{
+        bridge: "bridge";
+        foundation: "foundation";
+        product: "product";
+    }>;
+    definitions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        owner: z.ZodString;
+        maturity: z.ZodEnum<{
+            experimental: "experimental";
+            stable: "stable";
+        }>;
+        activation: z.ZodEnum<{
+            live: "live";
+            restart: "restart";
+        }>;
+        name: z.ZodString;
+        description: z.ZodString;
+        component: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ComponentFeatures = z.infer<typeof ComponentFeatures>;
+export declare const FeaturePreferences: z.ZodObject<{
+    optIn: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type FeaturePreferences = z.infer<typeof FeaturePreferences>;
+export interface FeatureComponent {
+    readonly id: string;
+    readonly version: string;
+    readonly requires?: Readonly<Record<string, string>>;
+    readonly features?: {
+        readonly kind: ComponentFeatures["kind"];
+        readonly definitions: readonly FeatureDefinition[];
+    };
+}
+export declare const FeaturePlan: z.ZodObject<{
+    definitions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        owner: z.ZodString;
+        maturity: z.ZodEnum<{
+            experimental: "experimental";
+            stable: "stable";
+        }>;
+        activation: z.ZodEnum<{
+            live: "live";
+            restart: "restart";
+        }>;
+        name: z.ZodString;
+        description: z.ZodString;
+        component: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    optIn: z.ZodArray<z.ZodString>;
+    selection: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>>;
+    components: z.ZodArray<z.ZodString>;
+    requirements: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type FeaturePlan = z.infer<typeof FeaturePlan>;
+export declare const FeatureStatus: z.ZodObject<{
+    id: z.ZodString;
+    definition: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        owner: z.ZodString;
+        maturity: z.ZodEnum<{
+            experimental: "experimental";
+            stable: "stable";
+        }>;
+        activation: z.ZodEnum<{
+            live: "live";
+            restart: "restart";
+        }>;
+        name: z.ZodString;
+        description: z.ZodString;
+        component: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    selected: z.ZodBoolean;
+    available: z.ZodBoolean;
+    enabled: z.ZodBoolean;
+    pendingRestart: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodEnum<{
+        "component-unselected": "component-unselected";
+        "dependency-unavailable": "dependency-unavailable";
+        "not-installed": "not-installed";
+        "restart-required": "restart-required";
+    }>>;
+}, z.core.$strip>;
+export type FeatureStatus = z.infer<typeof FeatureStatus>;
+export declare namespace FeatureSelection {
+    function complete(candidates: readonly FeatureComponent[], provided?: Readonly<Record<string, string>>): {
+        definitions: {
+            id: string;
+            owner: string;
+            maturity: "experimental" | "stable";
+            activation: "live" | "restart";
+            name: string;
+            description: string;
+            component?: string | undefined;
+        }[];
+        optIn: string[];
+        selection: {
+            id: string;
+            version: string;
+        }[];
+        components: string[];
+        requirements: Record<string, string[]>;
+    };
+    interface Options {
+        optIn?: readonly string[];
+        selection?: Readonly<Record<string, string>>;
+        provided?: Readonly<Record<string, string>>;
+    }
+    function resolve(candidates: readonly FeatureComponent[], options?: Options): FeaturePlan;
+    function status(plan: FeaturePlan, requested: readonly string[], effective: readonly string[]): FeatureStatus[];
+}

package/dist/features.js

@@ -0,0 +1,195 @@
+import { z } from "zod";
+const Id = z.string().regex(/^[a-z][a-z0-9.-]*$/);
+export const FeatureDefinition = z
+    .object({
+    id: Id,
+    owner: Id,
+    maturity: z.enum(["experimental", "stable"]),
+    activation: z.enum(["live", "restart"]),
+    name: z.string().min(1),
+    description: z.string().min(1),
+    component: Id.optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.component && value.activation !== "restart")
+        context.addIssue({ code: "custom", message: "Component features require restart activation" });
+})
+    .meta({ ref: "FeatureDefinition" });
+export const ComponentFeatures = z
+    .object({
+    kind: z.enum(["foundation", "product", "bridge"]),
+    definitions: z.array(FeatureDefinition),
+})
+    .strict();
+export const FeaturePreferences = z
+    .object({ optIn: z.array(Id).refine((ids) => new Set(ids).size === ids.length, "Duplicate experimental feature") })
+    .strict();
+export const FeaturePlan = z
+    .object({
+    definitions: z.array(FeatureDefinition),
+    optIn: FeaturePreferences.shape.optIn,
+    selection: z.array(z.object({ id: Id, version: z.string().min(1) }).strict()),
+    components: z.array(Id),
+    requirements: z.record(Id, z.array(Id)),
+})
+    .strict()
+    .refine((plan) => {
+    const active = activate(plan, plan.optIn);
+    return (plan.components.length === active.size &&
+        new Set(plan.components).size === active.size &&
+        plan.components.every((id) => active.has(id)));
+}, "Active components do not match feature selection");
+export const FeatureStatus = z
+    .object({
+    id: Id,
+    definition: FeatureDefinition.optional(),
+    selected: z.boolean(),
+    available: z.boolean(),
+    enabled: z.boolean(),
+    pendingRestart: z.boolean(),
+    reason: z.enum(["not-installed", "component-unselected", "dependency-unavailable", "restart-required"]).optional(),
+})
+    .meta({ ref: "FeatureStatus" });
+function activate(plan, optIn) {
+    const active = new Set(plan.selection.map((component) => component.id));
+    for (const definition of plan.definitions) {
+        if (definition.component && definition.maturity === "experimental" && !optIn.includes(definition.id))
+            active.delete(definition.component);
+    }
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const id of active) {
+            if (!(plan.requirements[id] ?? []).some((required) => !active.has(required)))
+                continue;
+            active.delete(id);
+            changed = true;
+        }
+    }
+    return active;
+}
+export var FeatureSelection;
+(function (FeatureSelection) {
+    function complete(candidates, provided) {
+        return resolve(candidates, {
+            provided,
+            optIn: candidates.flatMap((component) => component.features?.definitions
+                .filter((feature) => feature.maturity === "experimental")
+                .map((feature) => feature.id) ?? []),
+        });
+    }
+    FeatureSelection.complete = complete;
+    function resolve(candidates, options = {}) {
+        const optIn = FeaturePreferences.parse({ optIn: options.optIn ?? [] }).optIn;
+        const byID = new Map();
+        const definitions = new Map();
+        const gates = new Map();
+        for (const candidate of candidates) {
+            if (byID.has(candidate.id))
+                throw new Error(`Duplicate component: ${candidate.id}`);
+            byID.set(candidate.id, candidate);
+            if (!candidate.features)
+                continue;
+            const metadata = ComponentFeatures.parse(candidate.features);
+            if (metadata.kind === "product" && !metadata.definitions.length)
+                throw new Error(`Product component ${candidate.id} needs a feature declaration`);
+            for (const definition of metadata.definitions) {
+                if (definition.owner !== candidate.id || (definition.component && definition.component !== candidate.id))
+                    throw new Error(`Feature ${definition.id} must belong to ${candidate.id}`);
+                if (definitions.has(definition.id))
+                    throw new Error(`Duplicate feature: ${definition.id}`);
+                definitions.set(definition.id, definition);
+                if (!definition.component)
+                    continue;
+                if (gates.has(definition.component))
+                    throw new Error(`Multiple feature gates for ${definition.component}`);
+                gates.set(definition.component, definition);
+            }
+        }
+        for (const candidate of candidates) {
+            if (candidate.features?.kind === "bridge" || gates.get(candidate.id)?.maturity === "experimental")
+                continue;
+            const visited = new Set();
+            const check = (required) => {
+                if (visited.has(required))
+                    return;
+                visited.add(required);
+                if (gates.get(required)?.maturity === "experimental")
+                    throw new Error(`Component ${candidate.id} requires experimental ${required}; split an optional integration`);
+                for (const dependency of Object.keys(byID.get(required)?.requires ?? {}))
+                    check(dependency);
+            };
+            for (const required of Object.keys(candidate.requires ?? {}))
+                check(required);
+        }
+        const available = new Set();
+        const include = (id) => {
+            if (available.has(id) || options.provided?.[id])
+                return;
+            const candidate = byID.get(id);
+            if (!candidate)
+                throw new Error(`Component is not installed: ${id}`);
+            available.add(id);
+            if (candidate.features?.kind === "bridge")
+                return;
+            for (const required of Object.keys(candidate.requires ?? {}))
+                include(required);
+        };
+        for (const id of options.selection ? Object.keys(options.selection) : byID.keys()) {
+            include(id);
+            const version = byID.get(id)?.version ?? options.provided?.[id];
+            if (options.selection && options.selection[id] !== version)
+                throw new Error(`Component ${id} requires exact version ${options.selection[id]}; installed ${version}`);
+        }
+        const selected = candidates.filter((candidate) => available.has(candidate.id));
+        const plan = {
+            definitions: [...definitions.values()],
+            optIn,
+            selection: selected.map(({ id, version }) => ({ id, version })),
+            requirements: Object.fromEntries(selected.map((candidate) => [
+                candidate.id,
+                Object.keys(candidate.requires ?? {}).filter((id) => !options.provided?.[id]),
+            ])),
+        };
+        const active = activate(plan, optIn);
+        for (const candidate of selected) {
+            if (active.has(candidate.id) ||
+                candidate.features?.kind === "bridge" ||
+                gates.get(candidate.id)?.maturity === "experimental")
+                continue;
+            throw new Error(`Component ${candidate.id} requires an unavailable dependency; split an optional integration`);
+        }
+        return { ...plan, components: [...active] };
+    }
+    FeatureSelection.resolve = resolve;
+    function status(plan, requested, effective) {
+        const definitions = new Map(plan.definitions.map((definition) => [definition.id, definition]));
+        const owners = new Set(plan.selection.map((component) => component.id));
+        const next = activate(plan, requested);
+        return [...new Set([...definitions.keys(), ...requested])].map((id) => {
+            const definition = definitions.get(id);
+            const selected = definition?.maturity === "stable" || requested.includes(id);
+            const ownerDisabled = !!definition && !definition.component && !next.has(definition.owner);
+            const dependencyUnavailable = !!definition && (plan.requirements[definition.owner] ?? []).some((id) => !next.has(id));
+            const available = !!definition && owners.has(definition.owner) && !dependencyUnavailable && !ownerDisabled;
+            const enabled = !!definition && effective.includes(id);
+            const nextEnabled = !!definition && next.has(definition.owner) && selected;
+            const pendingRestart = !!definition &&
+                enabled !== nextEnabled &&
+                (definition.activation === "restart" ||
+                    plan.components.includes(definition.owner) !== next.has(definition.owner));
+            const reason = !definition
+                ? "not-installed"
+                : !owners.has(definition.owner)
+                    ? "component-unselected"
+                    : dependencyUnavailable || ownerDisabled
+                        ? "dependency-unavailable"
+                        : pendingRestart
+                            ? "restart-required"
+                            : undefined;
+            return { id, definition, selected, available, enabled, pendingRestart, ...(reason ? { reason } : {}) };
+        });
+    }
+    FeatureSelection.status = status;
+})(FeatureSelection || (FeatureSelection = {}));