symlx 0.1.3 → 0.1.5

package/dist/commands/serve_stash.js

@@ -0,0 +1,169 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveCommand = serveCommand;
+const path_1 = __importDefault(require("path"));
+const node_os_1 = __importDefault(require("node:os"));
+const log = __importStar(require("../ui/logger"));
+const utils_1 = require("../lib/utils");
+const link_manager_1 = require("../lib/link-manager");
+const bin_targets_1 = require("../lib/bin-targets");
+const lifecycle_1 = require("../lib/lifecycle");
+const session_store_1 = require("../lib/session-store");
+const prompts_1 = require("../ui/prompts");
+const options_1 = require("../lib/options");
+const schema_1 = require("../lib/schema");
+// Prompts require an interactive terminal; scripts/CI should avoid prompt mode.
+function isInteractiveSession() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function prepareRuntimeDirectories(binDirectory, sessionDirectory) {
+    (0, session_store_1.ensureSymlxDirectories)(binDirectory, sessionDirectory);
+    (0, session_store_1.cleanupStaleSessions)(sessionDirectory);
+}
+function resolveRuntimeCollisionMode(options) {
+    if (options.collision !== 'prompt') {
+        return { policy: options.collision };
+    }
+    const canPromptForCollision = !options.nonInteractive && isInteractiveSession();
+    if (canPromptForCollision) {
+        return {
+            policy: 'prompt',
+            resolver: prompts_1.promptCollisionDecision,
+        };
+    }
+    log.warn('prompt collision mode requested but session is non-interactive; falling back to skip (use --collision overwrite|fail to avoid skips)');
+    return { policy: 'skip' };
+}
+function buildServeRuntime(options) {
+    const currentWorkingDirectory = process.cwd();
+    const sessionDirectory = path_1.default.join(node_os_1.default.homedir(), '.symlx', 'sessions');
+    prepareRuntimeDirectories(options.binDir, sessionDirectory);
+    (0, bin_targets_1.assertValidBinTargets)(options.bin);
+    return {
+        cwd: currentWorkingDirectory,
+        options,
+        sessionDirectory,
+        bins: new Map(Object.entries(options.bin)),
+        collisionMode: resolveRuntimeCollisionMode(options),
+    };
+}
+async function createRuntimeLinks(runtime) {
+    return (0, link_manager_1.createLinks)({
+        bins: runtime.bins,
+        binDir: runtime.options.binDir,
+        policy: runtime.collisionMode.policy,
+        collisionResolver: runtime.collisionMode.resolver,
+    });
+}
+function formatSkippedLinks(skippedLinks) {
+    const maxVisibleSkips = 5;
+    const visibleSkips = skippedLinks.slice(0, maxVisibleSkips);
+    const visibleSkipLines = visibleSkips
+        .map((skip) => `- ${skip.name}: ${skip.reason}`)
+        .join('\n');
+    const hiddenSkipsCount = skippedLinks.length - maxVisibleSkips;
+    const hiddenSkipsLine = hiddenSkipsCount > 0 ? `\n- ...and ${hiddenSkipsCount} more` : '';
+    return `${visibleSkipLines}${hiddenSkipsLine}`;
+}
+function assertLinkCreationSucceeded(linkResult) {
+    if (linkResult.created.length > 0) {
+        return;
+    }
+    if (linkResult.skipped.length === 0) {
+        throw new Error('no links were created');
+    }
+    throw new Error([
+        'no links were created because all candidate commands were skipped.',
+        formatSkippedLinks(linkResult.skipped),
+        'use --collision overwrite or --collision fail for stricter behavior.',
+    ].join('\n'));
+}
+function persistServeSession(runtime, links) {
+    const sessionPath = (0, session_store_1.createSessionFilePath)(runtime.sessionDirectory);
+    const record = {
+        pid: process.pid,
+        cwd: runtime.cwd,
+        createdAt: new Date().toISOString(),
+        links,
+    };
+    (0, session_store_1.persistSession)(sessionPath, record);
+    return { sessionPath, record };
+}
+function registerServeSessionCleanup(session) {
+    (0, lifecycle_1.registerLifecycleCleanup)(() => {
+        (0, session_store_1.cleanupSession)(session.sessionPath, session.record.links);
+    });
+}
+function reportLinkCreation(runtime, linkResult) {
+    const createdLinks = linkResult.created;
+    log.info(`linked ${createdLinks.length} command${createdLinks.length > 1 ? 's' : ''} into ${runtime.options.binDir}`);
+    for (const link of createdLinks) {
+        log.info(`${link.name} -> ${link.target}`);
+    }
+    for (const skippedLink of linkResult.skipped) {
+        log.warn(`skip "${skippedLink.name}": ${skippedLink.reason} (${skippedLink.linkPath})`);
+    }
+}
+function reportPathHint(binDirectory) {
+    if ((0, utils_1.pathContainsDir)(process.env.PATH, binDirectory)) {
+        return;
+    }
+    log.info(`add this to your shell config if needed:\nexport PATH="${binDirectory}:$PATH"`);
+}
+function waitUntilProcessExit() {
+    return new Promise(() => {
+        setInterval(() => undefined, 60_000);
+    });
+}
+async function run(options) {
+    const runtime = buildServeRuntime(options);
+    const linkResult = await createRuntimeLinks(runtime);
+    assertLinkCreationSucceeded(linkResult);
+    const session = persistServeSession(runtime, linkResult.created);
+    registerServeSessionCleanup(session);
+    reportLinkCreation(runtime, linkResult);
+    reportPathHint(runtime.options.binDir);
+    log.info('running. press Ctrl+C to cleanup links.');
+    await waitUntilProcessExit();
+}
+function serveCommand(inlineOptions) {
+    const currentWorkingDirectory = process.cwd();
+    const options = (0, options_1.resolveOptions)(currentWorkingDirectory, schema_1.serveInlineOptionsSchema, inlineOptions);
+    return run(options);
+}

package/dist/lib/bin-targets.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareBinTargets = prepareBinTargets;
+const node_fs_1 = __importDefault(require("node:fs"));
+function isExecutable(filePath) {
+    if (process.platform === 'win32') {
+        return true;
+    }
+    try {
+        node_fs_1.default.accessSync(filePath, node_fs_1.default.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function ensureExecutable(filePath, currentMode) {
+    if (process.platform === 'win32' || isExecutable(filePath)) {
+        return undefined;
+    }
+    const executeBits = (currentMode & 0o444) >> 2;
+    const nextMode = (currentMode | executeBits) & 0o777;
+    try {
+        node_fs_1.default.chmodSync(filePath, nextMode);
+    }
+    catch (error) {
+        return `target permissions could not be updated (${String(error)})`;
+    }
+    if (isExecutable(filePath)) {
+        return undefined;
+    }
+    return 'target permissions could not be updated';
+}
+function inspectBinTarget(name, target) {
+    if (!node_fs_1.default.existsSync(target)) {
+        return {
+            name,
+            target,
+            reason: 'target file does not exist',
+        };
+    }
+    let stats;
+    try {
+        stats = node_fs_1.default.statSync(target);
+    }
+    catch (error) {
+        return {
+            name,
+            target,
+            reason: `target cannot be accessed (${String(error)})`,
+        };
+    }
+    if (stats.isDirectory()) {
+        return {
+            name,
+            target,
+            reason: 'target is a directory',
+        };
+    }
+    const executableIssue = ensureExecutable(target, stats.mode);
+    if (executableIssue) {
+        return {
+            name,
+            target,
+            reason: executableIssue,
+            hint: `run: chmod +x ${target}`,
+        };
+    }
+    return undefined;
+}
+function formatIssues(issues) {
+    return issues
+        .map((issue) => {
+        const hint = issue.hint ? ` (${issue.hint})` : '';
+        return `- ${issue.name} -> ${issue.target}: ${issue.reason}${hint}`;
+    })
+        .join('\n');
+}
+function prepareBinTargets(bin) {
+    const issues = [];
+    for (const [name, target] of Object.entries(bin)) {
+        const issue = inspectBinTarget(name, target);
+        if (issue) {
+            issues.push(issue);
+        }
+    }
+    if (issues.length === 0) {
+        return;
+    }
+    throw new Error([
+        'invalid bin targets:',
+        formatIssues(issues),
+        'fix bin paths or file permissions in package.json, symlx.config.json, or inline --bin and run again.',
+    ].join('\n'));
+}

package/dist/lib/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROMPT_FALLBACK_WARNING = void 0;
+exports.PROMPT_FALLBACK_WARNING = 'prompt collision mode requested but session is non-interactive; falling back to skip (use --collision overwrite|fail to avoid skips)';

package/dist/{services → lib}/link-manager.js

@@ -4,8 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLinks = createLinks;
+exports.assertLinksCreated = assertLinksCreated;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+const prompts_1 = require("../ui/prompts");
 // lstat wrapper that treats missing files as "not found" but rethrows real IO errors.
 function tryLstat(filePath) {
     try {
@@ -69,13 +71,15 @@ function toConflict(name, linkPath, target, node) {
 }
 // Creates symlinks for all project bins according to the selected collision strategy.
 // This function is pure with regard to policy: caller decides interactive vs non-interactive.
-async function createLinks(params) {
-    const { bins, binDir, policy, collisionResolver } = params;
+async function createLinks(bins, binDir, collisionOption) {
     const created = [];
     const skipped = [];
-    for (const [name, target] of bins.entries()) {
+    // Link every executable in the bin options
+    for (const [name, target] of Object.entries(bins)) {
         const linkPath = node_path_1.default.join(binDir, name);
+        // check is there's an existing binary on the device
         const existingNode = inspectExistingNode(linkPath);
+        // If there's a conflicting binary, handle the conflict
         if (existingNode) {
             const conflict = toConflict(name, linkPath, target, existingNode);
             // Reusing the exact same link is always a no-op.
@@ -88,25 +92,21 @@ async function createLinks(params) {
                 });
                 continue;
             }
-            let decision;
-            if (policy === 'skip') {
-                decision = 'skip';
-            }
-            else if (policy === 'overwrite') {
-                decision = 'overwrite';
-            }
-            else if (policy === 'fail') {
+            if (collisionOption === 'fail') {
                 throw new Error(`command "${name}" conflicts at ${linkPath}: ${conflict.reason}`);
             }
-            else {
-                decision = collisionResolver
-                    ? await collisionResolver(conflict)
-                    : 'skip';
+            let collisionDecision;
+            if (collisionOption === 'prompt') {
+                collisionDecision = await (0, prompts_1.promptCollisionResolver)(conflict);
+                if (collisionDecision === 'abort') {
+                    throw new Error(`aborted on collision for command "${name}"`);
+                }
             }
-            if (decision === 'abort') {
-                throw new Error(`aborted on collision for command "${name}"`);
+            else {
+                // After here, resulting decision can only either be 'skip' or 'overwrite'
+                collisionDecision = collisionOption;
             }
-            if (decision === 'skip') {
+            if (collisionDecision === 'skip') {
                 skipped.push({ name, linkPath, reason: conflict.reason });
                 continue;
             }
@@ -117,3 +117,22 @@ async function createLinks(params) {
     }
     return { created, skipped };
 }
+function assertLinksCreated(linkResult) {
+    if (linkResult.created.length > 0) {
+        return;
+    }
+    if (linkResult.skipped.length === 0) {
+        throw new Error('no links were created');
+    }
+    const details = linkResult.skipped
+        .slice(0, 5)
+        .map((skip) => `- ${skip.name}: ${skip.reason}`)
+        .join('\n');
+    const remainingCount = linkResult.skipped.length - 5;
+    const remaining = remainingCount > 0 ? `\n- ...and ${remainingCount} more` : '';
+    throw new Error([
+        'no links were created because all candidate commands were skipped.',
+        details,
+        `${remaining}\nuse --collision overwrite or --collision fail for stricter behavior.`,
+    ].join('\n'));
+}

package/dist/lib/link-result.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertLinksCreated = assertLinksCreated;
+function assertLinksCreated(linkResult) {
+    if (linkResult.created.length > 0) {
+        return;
+    }
+    if (linkResult.skipped.length === 0) {
+        throw new Error('no links were created');
+    }
+    const details = linkResult.skipped
+        .slice(0, 5)
+        .map((skip) => `- ${skip.name}: ${skip.reason}`)
+        .join('\n');
+    const remainingCount = linkResult.skipped.length - 5;
+    const remaining = remainingCount > 0 ? `\n- ...and ${remainingCount} more` : '';
+    throw new Error([
+        'no links were created because all candidate commands were skipped.',
+        details,
+        `${remaining}\nuse --collision overwrite or --collision fail for stricter behavior.`,
+    ].join('\n'));
+}

package/dist/lib/options.js

@@ -1,46 +1,140 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveOptions = resolveOptions;
+exports.resolveInternalCollisionOption = resolveInternalCollisionOption;
 const path_1 = __importDefault(require("path"));
 const node_os_1 = __importDefault(require("node:os"));
+const log = __importStar(require("../ui/logger"));
 const utils_1 = require("./utils");
-const validate_1 = require("./validate");
-const package_bins_1 = require("../services/package-bins");
-const defaultOptions = {
+const validator_1 = require("./validator");
+const DEFAULT_OPTIONS = {
     collision: 'prompt',
     nonInteractive: false,
     binDir: path_1.default.join(node_os_1.default.homedir(), '.symlx', 'bin'),
     bin: {},
+    binResolutionStrategy: 'replace',
 };
+function hasBinEntries(bin) {
+    return Boolean(bin && Object.keys(bin).length > 0);
+}
+function computeResolvedBin(inlineBin, configFileBin, packageJSONBin, binResolutionStrategy) {
+    // Aggregates bin from all sources:
+    // inline + config + package.json + default
+    if (binResolutionStrategy === 'merge') {
+        return {
+            ...(packageJSONBin ?? {}),
+            ...(configFileBin ?? {}),
+            ...(inlineBin ?? {}),
+        };
+    }
+    // Bin source precedence is value-aware:
+    // inline (if non-empty) -> config (if non-empty) -> package.json (if non-empty) -> default.
+    return hasBinEntries(inlineBin)
+        ? inlineBin
+        : hasBinEntries(configFileBin)
+            ? configFileBin
+            : hasBinEntries(packageJSONBin)
+                ? packageJSONBin
+                : DEFAULT_OPTIONS.bin;
+}
+function withCwdPrefixedBin(cwd, bin) {
+    return Object.fromEntries(Object.entries(bin).map(([name, target]) => [
+        name,
+        path_1.default.resolve(cwd, target),
+    ]));
+}
+function isInteractiveSession() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
 // Function to aggregate all options from different sources in order or priority
-function resolveOptions(inlineOptionsSchema, inlineOptions) {
-    // Load the bin from package.json
-    const packageJSONOptions = (0, package_bins_1.loadPackageJSONOptions)(process.cwd());
-    // Load and validate the options from the config file,
-    // silently overriding invalid non-critical values with defaults or inline based on order of priority
-    const configFileOptions = (0, utils_1.loadConfigFileOptions)();
-    const validatedConfigFileOptions = (0, validate_1.validateConfigFileOptions)(configFileOptions);
-    // Validate the CLI inline options if available
-    const validatedInlineOptions = (0, validate_1.validateInlineOptions)(inlineOptionsSchema, inlineOptions);
-    // Default options first
-    // -> Config file options override defaults
-    // -> CLI inline options overrides config file options
-    const finalOptiions = {
-        ...defaultOptions,
+function resolveOptions(cwd, inlineOptionsSchema, inlineOptions) {
+    const packageJSONLoadResult = (0, utils_1.loadPackageJSONOptions)(cwd);
+    const validatedPackageJSONOptions = (0, validator_1.validatePackageJSONOptions)(packageJSONLoadResult);
+    const packageJSONIssues = [
+        ...packageJSONLoadResult.issues,
+        ...validatedPackageJSONOptions.issues,
+    ];
+    const configFileLoadResult = (0, utils_1.loadConfigFileOptions)(cwd);
+    const validatedConfigFileOptions = (0, validator_1.validateConfigFileOptions)(configFileLoadResult.options);
+    const validatedInlineOptions = (0, validator_1.validateInlineOptions)(inlineOptionsSchema, inlineOptions);
+    const inlineBin = validatedInlineOptions
+        .bin;
+    const mergedOptions = {
+        ...DEFAULT_OPTIONS,
+        ...(validatedPackageJSONOptions ?? {}),
         ...(validatedConfigFileOptions ?? {}),
         ...(validatedInlineOptions ?? {}),
     };
-    if (!Object.entries(finalOptiions.bin).length) {
-        throw new Error([
-            'no bin entries found. add at least one bin in any of these places:',
-            '1) package.json -> "bin": { "my-cli": "./cli.js" }',
-            '2) symlx.config.json -> "bin": { "my-cli": "./cli.js" }',
-            '3) inline CLI -> symlx serve --bin my-cli=./cli.js',
-            '4) if package.json "bin" is a string, set a valid package.json "name" (used to infer the bin name).',
-        ].join('\n'));
+    const resolvedBin = computeResolvedBin(inlineBin, validatedConfigFileOptions.bin, validatedPackageJSONOptions.bin, mergedOptions.binResolutionStrategy);
+    const finalOptions = {
+        ...mergedOptions,
+        bin: withCwdPrefixedBin(cwd, resolvedBin),
+    };
+    if (Object.keys(finalOptions.bin).length > 0) {
+        if (finalOptions.binResolutionStrategy === 'merge' &&
+            packageJSONIssues.length > 0) {
+            log.warn([
+                'bin resolution strategy is merge, but could not resolve bin from package.json:',
+                ...packageJSONIssues,
+            ].join('\n'));
+        }
+        return finalOptions;
+    }
+    // only throw package.json error if no bin was resolved
+    const primaryIssue = packageJSONIssues[0];
+    if (primaryIssue) {
+        throw new Error(primaryIssue);
+    }
+    throw new Error([
+        'no bin entries found.',
+        'add at least one command in one of these places:',
+        '1) package.json -> "bin": { "my-cli": "./cli.js" }',
+        '2) symlx.config.json -> "bin": { "my-cli": "./cli.js" }',
+        '3) inline CLI -> symlx serve --bin my-cli=./cli.js',
+    ].join('\n'));
+}
+function resolveInternalCollisionOption(collisionOptions, nonInteractiveOptions) {
+    if (collisionOptions !== 'prompt') {
+        return collisionOptions;
+    }
+    if (nonInteractiveOptions || !isInteractiveSession()) {
+        return 'skip';
     }
-    return finalOptiions;
+    return 'prompt';
 }

package/dist/lib/schema.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serveInlineOptionsSchema = exports.configFileOptionsSchema = exports.binEntriesToRecordSchema = void 0;
+exports.serveInlineOptionsSchema = exports.configFileOptionsSchema = exports.packageJSONOptionsSchema = void 0;
 const zod_1 = require("zod");
 const log = __importStar(require("../ui/logger"));
 const binNameSchema = zod_1.z
@@ -43,17 +43,36 @@ const binTargetSchema = zod_1.z
     .string()
     .trim()
     .min(1)
-    .regex(/^\.{1,2}\//, 'bin target must be a relative path like ./cli.js');
-const customBinSchema = zod_1.z.record(binNameSchema, binTargetSchema);
+    .regex(/^(?!\/)(?![A-Za-z]:[\\/])(?!(?:\\\\|\/\/)).+/, 'bin target must be a relative path like ./cli.js');
+const binRecordSchema = zod_1.z.record(binNameSchema, binTargetSchema);
+const binEntrySchema = zod_1.z
+    .string()
+    .regex(/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?=(?!\/)(?![A-Za-z]:[\\/])(?!(?:\\\\|\/\/)).+$/, 'expected <name=relative/path>');
+const binEntriesToRecordSchema = zod_1.z
+    .array(binEntrySchema)
+    .optional()
+    .default([])
+    .transform((entries) => Object.fromEntries(entries.map((entry) => {
+    const [name, target] = entry.split('=', 2);
+    return [name, target];
+})));
+const collisionOptionEnum = zod_1.z.enum(['prompt', 'skip', 'fail', 'overwrite']);
+// -------------------------------------------
+// package.json Schema: Just bin for now
+// -------------------------------------------
+const packageJSONOptionsSchema = zod_1.z.object({
+    bin: binRecordSchema.optional(),
+});
+exports.packageJSONOptionsSchema = packageJSONOptionsSchema;
+// -------------------------------------------
+// symlx.config.json options: should allow configuring all options
+// -------------------------------------------
 const configFileOptionsSchema = zod_1.z.object({
     binDir: zod_1.z
         .string()
         .regex(/(^|[\\/])\.[^\\/]+([\\/]|$)/, 'binDir must include a dotted folder segment')
         .optional(),
-    collision: zod_1.z
-        .enum(['prompt', 'skip', 'fail', 'overwrite'])
-        .optional()
-        .catch(() => {
+    collision: collisionOptionEnum.optional().catch(() => {
         log.warn('invalid "collision" value in config file; using default.');
         return undefined;
     }),
@@ -64,21 +83,21 @@ const configFileOptionsSchema = zod_1.z.object({
         log.warn('invalid "nonInteractive" value in config file; using default.');
         return undefined;
     }),
-    bin: customBinSchema.optional(),
+    bin: binRecordSchema.optional(),
+    binResolutionStrategy: zod_1.z.enum(['replace', 'merge']).optional(),
 });
 exports.configFileOptionsSchema = configFileOptionsSchema;
-const binEntrySchema = zod_1.z
-    .string()
-    .regex(/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?=\.{1,2}\/.+$/, 'expected <name=./relative/path>');
-exports.binEntriesToRecordSchema = zod_1.z
-    .array(binEntrySchema)
-    .optional()
-    .default([])
-    .transform((entries) => Object.fromEntries(entries.map((entry) => {
-    const [name, target] = entry.split('=', 2);
-    return [name, target];
-})));
-const serveInlineOptionsSchema = configFileOptionsSchema.extend({
-    bin: exports.binEntriesToRecordSchema,
+// -------------------------------------------
+// varying command inline options: highest priority in field:value resolution
+// -------------------------------------------
+const serveInlineOptionsSchema = configFileOptionsSchema
+    .pick({
+    binDir: true,
+    collision: true,
+    nonInteractive: true,
+    binResolutionStrategy: true,
+})
+    .extend({
+    bin: binEntriesToRecordSchema,
 });
 exports.serveInlineOptionsSchema = serveInlineOptionsSchema;