@fission-ai/openspec 1.13.0 → 1.13.2

package/dist/core/version-check.js

@@ -5,7 +5,8 @@ import path from 'path';
 import { createRequire } from 'module';
 import chalk from 'chalk';
 import { isCiEnvironment } from '../utils/ci.js';
-import { getGlobalConfig } from './global-config.js';
+import { isTelemetryOptedOutByEnv } from '../telemetry/opt-out.js';
+import { getGlobalConfig, isGlobalConfigUnreadable } from './global-config.js';
 const require = createRequire(import.meta.url);
 const { name: PACKAGE_NAME, version: OPENSPEC_VERSION } = require('../../package.json');
 const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
@@ -29,9 +30,7 @@ const SAFE_VERSION = /^\d{1,10}\.\d{1,10}\.\d{1,10}(?:-[0-9A-Za-z.-]{1,64})?(?:\
 function isCheckEnabled() {
     if (process.env.OPENSPEC_NO_UPDATE_CHECK !== undefined)
         return false;
-    if (process.env.DO_NOT_TRACK === '1')
-        return false;
-    if (process.env.OPENSPEC_TELEMETRY === '0')
+    if (isTelemetryOptedOutByEnv())
         return false;
     if (isCiEnvironment())
         return false;
@@ -40,21 +39,53 @@ function isCheckEnabled() {
     // Same config opt-out as telemetry (env remains the hard override above).
     if (getGlobalConfig().telemetry?.enabled === false)
         return false;
+    // A config that cannot be parsed may be hiding that opt-out.
+    if (isGlobalConfigUnreadable())
+        return false;
     return true;
 }
 /**
- * The registry to ask: only the environment variable npm exports (under
- * `npm run`, or an explicit export). Deliberately not a `registry=` line from
- * any .npmrc — letting file contents choose the destination of an outbound
- * request is a flow worth avoiding for a convenience this small, and a project
- * file would travel with a cloned repository. Anyone on a private mirror can
- * export `npm_config_registry`, or turn the check off entirely.
+ * The configured registry, if npm exported one. Not trustworthy: npm exports
+ * every config source it read, including a `registry=` line in a
+ * repository-local .npmrc that travels with a clone.
  */
-export function registryUrl() {
+function configuredRegistry() {
     const configured = process.env.npm_config_registry?.trim();
-    const base = configured && /^https?:\/\//i.test(configured) ? configured : DEFAULT_REGISTRY;
+    return configured ? configured : undefined;
+}
+/**
+ * The registry to ask. A configured registry is honored only over TLS: a
+ * cleartext hop would aim the request at a link-local or internal address and
+ * let anyone on the path choose the "newer version" answer.
+ *
+ * A rejected registry disables the check rather than falling back to public
+ * npm. Falling back would send a request an organization on an internal mirror
+ * deliberately avoided, and would then report a version resolved against a
+ * registry the eventual `npm install -g` does not use.
+ */
+export function registryUrl() {
+    const configured = configuredRegistry();
+    if (configured && !/^https:\/\//i.test(configured))
+        return null;
+    const base = configured ?? DEFAULT_REGISTRY;
     return `${base.replace(/\/+$/, '')}/${PACKAGE_NAME}/latest`;
 }
+/**
+ * True when the check is talking to the public npm registry. Read from the raw
+ * env var, not from registryUrl(), so a registry that was rejected above still
+ * disqualifies a self-upgrade instead of looking like the default.
+ */
+function isDefaultRegistry() {
+    const configured = configuredRegistry();
+    if (!configured)
+        return true;
+    try {
+        return new URL(configured).origin === new URL(DEFAULT_REGISTRY).origin;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Compares two prerelease tags per SemVer: dot-separated identifiers compared
  * one by one, numeric identifiers numerically (so beta.10 > beta.2), numeric
@@ -141,7 +172,12 @@ function fetchLatestVersion() {
         };
         let url;
         try {
-            url = new URL(registryUrl());
+            const resolved = registryUrl();
+            if (resolved === null) {
+                resolve(null);
+                return;
+            }
+            url = new URL(resolved);
         }
         catch {
             resolve(null);
@@ -169,10 +205,13 @@ function fetchLatestVersion() {
                     redirectsLeft -= 1;
                     try {
                         const next = new URL(location, target);
-                        // Never follow a downgrade to plain http: a MITM on the reply
-                        // would control the "newer version" answer.
-                        const downgrade = target.protocol === 'https:' && next.protocol === 'http:';
-                        if (!downgrade && (next.protocol === 'http:' || next.protocol === 'https:')) {
+                        // Cross-host is allowed - that is the whole point of following a
+                        // redirect for a mirror or corporate front-end - but never off
+                        // TLS: a MITM on a cleartext hop would control the "newer
+                        // version" answer, and the reply cannot install anything on its
+                        // own (canSelfUpgrade refuses a non-default registry, and the
+                        // version is re-validated against a strict pattern).
+                        if (next.protocol === 'https:') {
                             send(next);
                             return;
                         }
@@ -492,10 +531,17 @@ function loadSpawn() {
  * that may not be the one on PATH, a project dependency belongs to that
  * project's package manager, an npx/dlx cache has nothing to upgrade, and a
  * source checkout is not an install at all.
+ *
+ * A non-default registry is also disqualifying. `npm install -g` resolves
+ * against whatever `npm_config_registry` says, which npm may have read from a
+ * cloned repository's .npmrc — so such a registry may still inform the check,
+ * but must never be the thing that offers to install a global package.
  */
 export function canSelfUpgrade(installDir, projectPath) {
     if (!installDir)
         return false;
+    if (!isDefaultRegistry())
+        return false;
     if (isEphemeralRunnerInstall(installDir))
         return false;
     // Both anchors matter: `openspec update ../other` from a project that owns

package/dist/core/worksets.js

@@ -175,7 +175,7 @@ export function worksetNotFoundError(name, state) {
     });
 }
 export function withWorkset(state, workset) {
-    if (state.worksets[workset.name] !== undefined) {
+    if (Object.prototype.hasOwnProperty.call(state.worksets, workset.name)) {
         throw new StoreError(`Workset '${workset.name}' already exists.`, 'workset_exists', {
             target: 'workset.name',
             fix: `Choose another name, or remove it first: openspec workset remove ${workset.name}`,
@@ -193,7 +193,7 @@ export function withWorkset(state, workset) {
     };
 }
 export function withoutWorkset(state, name) {
-    if (state.worksets[name] === undefined) {
+    if (!Object.prototype.hasOwnProperty.call(state.worksets, name)) {
         throw worksetNotFoundError(name, state);
     }
     const remaining = { ...state.worksets };
@@ -226,8 +226,10 @@ export function listWorksets(state) {
         .sort((a, b) => a.name.localeCompare(b.name));
 }
 export function getWorkset(state, name) {
-    const entry = state.worksets[name];
-    return entry === undefined ? null : toWorkset(name, entry);
+    if (!Object.prototype.hasOwnProperty.call(state.worksets, name)) {
+        return null;
+    }
+    return toWorkset(name, state.worksets[name]);
 }
 /**
  * The generated .code-workspace content: members in saved order with

package/dist/prompts/searchable-multi-select.d.ts

@@ -1,6 +1,11 @@
 interface Choice {
     name: string;
     value: string;
+    /**
+     * Extra terms the search box matches, for choices users look for by a word
+     * the name does not spell (see #653). Never rendered.
+     */
+    searchAliases?: string[];
     description?: string;
     configured?: boolean;
     detected?: boolean;
@@ -12,6 +17,8 @@ interface Config {
     choices: Choice[];
     pageSize?: number;
     validate?: (selected: string[]) => boolean | string;
+    /** Shown when a search matches nothing, so the list is not a dead end. */
+    emptyHint?: string;
 }
 /**
  * A searchable multi-select prompt with visible search box,

package/dist/prompts/searchable-multi-select.js

@@ -1,4 +1,11 @@
 import chalk from 'chalk';
+/**
+ * True when every character is printable, so the text can go in the search box.
+ * `\u007f` is DEL, which sorts above the printable range.
+ */
+function isPrintable(text) {
+    return text.length > 0 && [...text].every((char) => char >= ' ' && char !== '\u007f');
+}
 /**
  * Create the searchable multi-select prompt.
  * Uses dynamic import to prevent pre-commit hook hangs (see #367).
@@ -6,7 +13,7 @@ import chalk from 'chalk';
 async function createSearchableMultiSelect() {
     const { createPrompt, useState, useKeypress, useMemo, usePrefix, isEnterKey, isBackspaceKey, isUpKey, isDownKey, } = await import('@inquirer/core');
     return createPrompt((config, done) => {
-        const { message, choices, pageSize = 15, validate } = config;
+        const { message, choices, pageSize = 15, validate, emptyHint } = config;
         const [searchText, setSearchText] = useState('');
         const [selectedValues, setSelectedValues] = useState(() => choices.filter(c => c.preSelected).map(c => c.value));
         const [cursor, setCursor] = useState(0);
@@ -17,9 +24,10 @@ async function createSearchableMultiSelect() {
         const filteredChoices = useMemo(() => {
             if (!searchText.trim())
                 return choices;
-            const term = searchText.toLowerCase();
+            const term = searchText.trim().toLowerCase();
             return choices.filter((c) => c.name.toLowerCase().includes(term) ||
-                c.value.toLowerCase().includes(term));
+                c.value.toLowerCase().includes(term) ||
+                (c.searchAliases ?? []).some((alias) => alias.toLowerCase().includes(term)));
         }, [searchText, choices]);
         const selectedSet = useMemo(() => new Set(selectedValues), [selectedValues]);
         const choiceMap = useMemo(() => new Map(choices.map((c) => [c.value, c])), [choices]);
@@ -72,9 +80,28 @@ async function createSearchableMultiSelect() {
                 setCursor(Math.min(filteredChoices.length - 1, cursor + 1));
                 return;
             }
-            // Character input - handle printable characters
-            if (key.name && key.name.length === 1 && !key.ctrl) {
-                setSearchText(searchText + key.name);
+            // Character input - handle printable characters.
+            // readline reports punctuation (`.`, `-`, `/`) only in `sequence`, leaving
+            // `name` undefined, so keying off `name` alone silently dropped every
+            // non-alphanumeric character the user typed.
+            // `@inquirer/core` types only `name` and `ctrl`; readline emits more.
+            const event = key;
+            if (event.ctrl || event.meta)
+                return;
+            // Requiring every character to be printable drops escape sequences
+            // (arrows, function keys), tab, escape and delete. readline splits a
+            // paste into one key per character, so a pasted space still toggles.
+            const typed = typeof event.sequence === 'string' && isPrintable(event.sequence)
+                ? event.sequence
+                : // Only the sequence may be multi-character: readline `name`s such as
+                    // 'tab' and 'escape' are printable strings but not typed input.
+                    typeof event.name === 'string' &&
+                        event.name.length === 1 &&
+                        isPrintable(event.name)
+                        ? event.name
+                        : undefined;
+            if (typed) {
+                setSearchText(searchText + typed);
                 setCursor(0);
             }
         });
@@ -102,6 +129,8 @@ async function createSearchableMultiSelect() {
         // List
         if (filteredChoices.length === 0) {
             lines.push(chalk.yellow('  No matches'));
+            if (emptyHint)
+                lines.push(chalk.dim(`  ${emptyHint}`));
         }
         else {
             // Calculate pagination

package/dist/telemetry/config.js

@@ -5,7 +5,7 @@
 import { promises as fs } from 'fs';
 import path from 'path';
 import os from 'os';
-import { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, getGlobalConfigDir, } from '../core/global-config.js';
+import { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, getGlobalConfigDir, isConfigRootObject, unreadableGlobalConfigMessage, } from '../core/global-config.js';
 // Constants
 export const CONFIG_DIR_NAME = GLOBAL_CONFIG_DIR_NAME;
 export const CONFIG_FILE_NAME = GLOBAL_CONFIG_FILE_NAME;
@@ -18,7 +18,14 @@ function getLegacyConfigPath() {
 async function readConfigFile(configPath) {
     try {
         const content = await fs.readFile(configPath, 'utf-8');
-        return { status: 'ok', config: JSON.parse(content) };
+        const parsed = JSON.parse(content);
+        // Valid JSON that is not an object carries no settings to merge into, and
+        // spreading it would replace the file (a string even spreads to numeric
+        // character keys). Same predicate the rest of the CLI refuses to save over.
+        if (!isConfigRootObject(parsed)) {
+            return { status: 'invalid', config: {} };
+        }
+        return { status: 'ok', config: parsed };
     }
     catch (error) {
         if (error.code === 'ENOENT') {
@@ -108,6 +115,11 @@ export async function readConfig() {
  */
 export async function writeConfig(updates) {
     const configPath = getConfigPath();
+    // Never write over a file that did not parse: the merge below would start
+    // from an empty object and replace every setting in it with these updates.
+    if ((await readConfigFile(configPath)).status === 'invalid') {
+        throw new Error(unreadableGlobalConfigMessage(configPath));
+    }
     // Read existing config and merge
     const existing = await readConfig();
     const merged = { ...existing, ...updates };

package/dist/telemetry/index.d.ts

@@ -2,11 +2,12 @@
  * Check if telemetry is enabled.
  *
  * Precedence (first match wins):
- * 1. OPENSPEC_TELEMETRY=0 → disabled
- * 2. DO_NOT_TRACK=1 → disabled
+ * 1. OPENSPEC_TELEMETRY set to anything but an on-value (1/true/yes/on) → disabled
+ * 2. DO_NOT_TRACK set to anything but an off-value (0/false/no/off) → disabled
  * 3. CI set to a truthy/on value → disabled (same rule as version-check)
  * 4. global config telemetry.enabled === false → disabled
- * 5. otherwise enabled (unset config means on; opt-out model)
+ * 5. global config file exists but cannot be parsed → disabled
+ * 6. otherwise enabled (unset config means on; opt-out model)
  *
  * Kept synchronous so call sites need not become async. Reads config via
  * sync getGlobalConfig() rather than async getTelemetryConfig().

package/dist/telemetry/index.js

@@ -20,9 +20,10 @@
  * versions and broke installs (#1390).
  */
 import { randomUUID } from 'crypto';
-import { getGlobalConfig } from '../core/global-config.js';
+import { getGlobalConfig, isGlobalConfigUnreadable } from '../core/global-config.js';
 import { isCiEnvironment } from '../utils/ci.js';
 import { getTelemetryConfig, updateTelemetryConfig } from './config.js';
+import { isTelemetryOptedOutByEnv } from './opt-out.js';
 // PostHog API key - public key for client-side analytics
 // This is safe to embed as it only allows sending events, not reading data
 const POSTHOG_API_KEY = 'phc_Hthu8YvaIJ9QaFKyTG4TbVwkbd5ktcAFzVTKeMmoW2g';
@@ -59,22 +60,21 @@ async function safeTelemetryFetch(url, options) {
  * Check if telemetry is enabled.
  *
  * Precedence (first match wins):
- * 1. OPENSPEC_TELEMETRY=0 → disabled
- * 2. DO_NOT_TRACK=1 → disabled
+ * 1. OPENSPEC_TELEMETRY set to anything but an on-value (1/true/yes/on) → disabled
+ * 2. DO_NOT_TRACK set to anything but an off-value (0/false/no/off) → disabled
  * 3. CI set to a truthy/on value → disabled (same rule as version-check)
  * 4. global config telemetry.enabled === false → disabled
- * 5. otherwise enabled (unset config means on; opt-out model)
+ * 5. global config file exists but cannot be parsed → disabled
+ * 6. otherwise enabled (unset config means on; opt-out model)
  *
  * Kept synchronous so call sites need not become async. Reads config via
  * sync getGlobalConfig() rather than async getTelemetryConfig().
  */
 export function isTelemetryEnabled() {
-    // Check explicit opt-out
-    if (process.env.OPENSPEC_TELEMETRY === '0') {
-        return false;
-    }
-    // Respect DO_NOT_TRACK standard
-    if (process.env.DO_NOT_TRACK === '1') {
+    // Explicit opt-out, and the DO_NOT_TRACK standard. Both are read
+    // tolerantly (see opt-out.ts): an opt-out that only worked for one exact
+    // spelling would leave users tracked who believe they are not.
+    if (isTelemetryOptedOutByEnv()) {
         return false;
     }
     // Auto-disable in CI environments (providers use true/1/yes/…)
@@ -85,6 +85,11 @@ export function isTelemetryEnabled() {
     if (getGlobalConfig().telemetry?.enabled === false) {
         return false;
     }
+    // A config file that cannot be parsed reads as defaults, which carry no
+    // opt-out, but the file itself may hold one. Unknown is not consent.
+    if (isGlobalConfigUnreadable()) {
+        return false;
+    }
     return true;
 }
 /**
@@ -144,6 +149,13 @@ export async function trackCommand(commandName, version) {
         return;
     }
     try {
+        // Disclosure before collection. A --json run defers the notice (printing
+        // it would corrupt machine-readable output), and for a user whose runs
+        // are all --json it may never have appeared — so nothing is sent, and no
+        // anonymous id is created, until the notice has actually been shown.
+        if (!(await getTelemetryConfig()).noticeSeen) {
+            return;
+        }
         const userId = await getOrCreateAnonymousId();
         sendEvent(userId, 'command_executed', {
             command: commandName,

package/dist/telemetry/opt-out.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Telemetry opt-out signals, shared by telemetry and the version check so both
+ * outbound surfaces honor exactly the same values.
+ *
+ * Parsing is tolerant in the style of isCiEnvironment(): a user who wrote
+ * DO_NOT_TRACK=true meant it, and an exact-match test that silently kept
+ * sending would be a privacy control that does not work. Ambiguity fails
+ * safe — a value we cannot read as "on" suppresses the request rather than
+ * enabling it.
+ */
+/** True when `DO_NOT_TRACK` is set to anything but an explicit off-value. */
+export declare function isDoNotTrackSet(env?: NodeJS.ProcessEnv): boolean;
+/** True when `OPENSPEC_TELEMETRY` is set to anything but an explicit on-value. */
+export declare function isTelemetryDisabledByEnv(env?: NodeJS.ProcessEnv): boolean;
+/** True when either opt-out signal asks us to stay off the network. */
+export declare function isTelemetryOptedOutByEnv(env?: NodeJS.ProcessEnv): boolean;
+//# sourceMappingURL=opt-out.d.ts.map

package/dist/telemetry/opt-out.js

@@ -0,0 +1,27 @@
+/**
+ * Telemetry opt-out signals, shared by telemetry and the version check so both
+ * outbound surfaces honor exactly the same values.
+ *
+ * Parsing is tolerant in the style of isCiEnvironment(): a user who wrote
+ * DO_NOT_TRACK=true meant it, and an exact-match test that silently kept
+ * sending would be a privacy control that does not work. Ambiguity fails
+ * safe — a value we cannot read as "on" suppresses the request rather than
+ * enabling it.
+ */
+const ON_VALUES = new Set(['1', 'true', 'yes', 'on']);
+const OFF_VALUES = new Set(['', '0', 'false', 'no', 'off']);
+/** True when `DO_NOT_TRACK` is set to anything but an explicit off-value. */
+export function isDoNotTrackSet(env = process.env) {
+    const value = env.DO_NOT_TRACK;
+    return value !== undefined && !OFF_VALUES.has(value.trim().toLowerCase());
+}
+/** True when `OPENSPEC_TELEMETRY` is set to anything but an explicit on-value. */
+export function isTelemetryDisabledByEnv(env = process.env) {
+    const value = env.OPENSPEC_TELEMETRY;
+    return value !== undefined && !ON_VALUES.has(value.trim().toLowerCase());
+}
+/** True when either opt-out signal asks us to stay off the network. */
+export function isTelemetryOptedOutByEnv(env = process.env) {
+    return isTelemetryDisabledByEnv(env) || isDoNotTrackSet(env);
+}
+//# sourceMappingURL=opt-out.js.map

package/dist/utils/file-system.js

@@ -1,5 +1,6 @@
 import * as nodeFs from 'fs';
 import path from 'path';
+import { detectLineEnding, matchLineEnding } from './line-endings.js';
 const fs = nodeFs.promises;
 const { constants: fsConstants } = nodeFs;
 function hasOwnerGroupOrOtherWriteBit(stats) {
@@ -277,8 +278,14 @@ export class FileSystemUtils {
     }
     static async updateFileWithMarkers(filePath, content, startMarker, endMarker) {
         let existingContent = '';
+        // The managed block is composed with '\n', so splicing it into a CRLF file
+        // would leave mixed endings behind. bash reports a stray '\r' in .bashrc as
+        // "$'\r': command not found", so settle the whole file on the convention it
+        // already used. A file that does not exist yet stays LF.
+        let originalContent;
         if (await this.fileExists(filePath)) {
             existingContent = await this.readFile(filePath);
+            originalContent = existingContent;
             const startIndex = findMarkerIndex(existingContent, startMarker);
             const endIndex = startIndex !== -1
                 ? findMarkerIndex(existingContent, endMarker, startIndex + startMarker.length)
@@ -301,7 +308,9 @@ export class FileSystemUtils {
         else {
             existingContent = startMarker + '\n' + content + '\n' + endMarker;
         }
-        await this.writeFile(filePath, existingContent);
+        await this.writeFile(filePath, originalContent === undefined
+            ? existingContent
+            : matchLineEnding(existingContent, originalContent));
     }
     static async ensureWritePermissions(dirPath) {
         try {
@@ -377,14 +386,22 @@ export function removeMarkerBlock(content, startMarker, endMarker) {
     }
     const before = content.substring(0, lineStart);
     const after = content.substring(lineEnd);
+    // The file's own newline, used for every ending this function writes. The
+    // blank-line collapse below rebuilds the separator it matched, so spelling it
+    // '\n' would leave a CRLF file with a mixed pair wherever a run was collapsed
+    // - the stray '\r' that bash reports as "$'\r': command not found".
+    //
+    // Dominant rather than "contains a CRLF anywhere", so that one stray CRLF in
+    // an otherwise-LF file does not pull the whole rewrite to CRLF. This is the
+    // same reading matchLineEnding uses, so both write paths agree.
+    const newline = detectLineEnding(content) ?? '\n';
     // Clean up double blank lines (handle both Unix \n and Windows \r\n)
     let result = before + after;
-    result = result.replace(/(\r?\n){3,}/g, '\n\n');
+    result = result.replace(/(\r?\n){3,}/g, newline + newline);
     // Trim trailing whitespace but preserve leading whitespace and original newline style
     if (result.trimEnd() === '') {
         return '';
     }
-    const newline = content.includes('\r\n') ? '\r\n' : '\n';
     return result.trimEnd() + newline;
 }
 //# sourceMappingURL=file-system.js.map

package/dist/utils/line-endings.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Line-ending helpers.
+ *
+ * Every parser in this codebase normalizes CRLF to LF on the way in, so all
+ * serialization logic can assume '\n'. That leaves the write side responsible
+ * for restoring whatever convention the file already used: without it, editing
+ * one requirement in a CRLF spec rewrites every line of the file and buries the
+ * real change in the diff.
+ */
+export type LineEnding = '\n' | '\r\n';
+/**
+ * The dominant line ending in `content`, or undefined when it holds no line
+ * break to judge from.
+ *
+ * Mixed files resolve to whichever ending is more common, with CRLF winning a
+ * tie: a file that is mostly CRLF is a CRLF file that picked up a stray LF, and
+ * settling the whole file on one ending is what keeps later diffs small.
+ */
+export declare function detectLineEnding(content: string): LineEnding | undefined;
+/**
+ * Re-apply `ending` to LF-normalized `content`.
+ *
+ * Normalizes to LF first, so the result is uniform even if the caller passed
+ * content that already contained CRLF.
+ */
+export declare function applyLineEnding(content: string, ending: LineEnding): string;
+/**
+ * Rewrite `content` to match the convention of `original`.
+ *
+ * When `original` has no line break to learn from, `content` is left as LF —
+ * the portable default this project writes new files with.
+ */
+export declare function matchLineEnding(content: string, original: string): string;
+//# sourceMappingURL=line-endings.d.ts.map

package/dist/utils/line-endings.js

@@ -0,0 +1,46 @@
+/**
+ * Line-ending helpers.
+ *
+ * Every parser in this codebase normalizes CRLF to LF on the way in, so all
+ * serialization logic can assume '\n'. That leaves the write side responsible
+ * for restoring whatever convention the file already used: without it, editing
+ * one requirement in a CRLF spec rewrites every line of the file and buries the
+ * real change in the diff.
+ */
+/**
+ * The dominant line ending in `content`, or undefined when it holds no line
+ * break to judge from.
+ *
+ * Mixed files resolve to whichever ending is more common, with CRLF winning a
+ * tie: a file that is mostly CRLF is a CRLF file that picked up a stray LF, and
+ * settling the whole file on one ending is what keeps later diffs small.
+ */
+export function detectLineEnding(content) {
+    const crlf = content.match(/\r\n/g)?.length ?? 0;
+    // Count LFs not preceded by CR, so CRLF is never also counted as LF.
+    const lf = content.match(/(?<!\r)\n/g)?.length ?? 0;
+    if (crlf === 0 && lf === 0)
+        return undefined;
+    return crlf >= lf ? '\r\n' : '\n';
+}
+/**
+ * Re-apply `ending` to LF-normalized `content`.
+ *
+ * Normalizes to LF first, so the result is uniform even if the caller passed
+ * content that already contained CRLF.
+ */
+export function applyLineEnding(content, ending) {
+    const normalized = content.replace(/\r\n/g, '\n');
+    return ending === '\n' ? normalized : normalized.replace(/\n/g, '\r\n');
+}
+/**
+ * Rewrite `content` to match the convention of `original`.
+ *
+ * When `original` has no line break to learn from, `content` is left as LF —
+ * the portable default this project writes new files with.
+ */
+export function matchLineEnding(content, original) {
+    const ending = detectLineEnding(original);
+    return ending === undefined ? content : applyLineEnding(content, ending);
+}
+//# sourceMappingURL=line-endings.js.map

package/dist/utils/nested-change.d.ts

@@ -0,0 +1,35 @@
+/** A namespace folder under `changes/` and the change directories buried in it. */
+export interface NestedChangeFinding {
+    /** The directory name directly under `changes/` that is not a change. */
+    name: string;
+    /**
+     * Slash-separated paths of the nested change directories, relative to
+     * `changes/`, sorted. Always at least one entry.
+     */
+    nested: string[];
+}
+/**
+ * Reports whether the directory `changes/<name>/` is a namespace folder holding
+ * one or more nested change directories rather than a change of its own.
+ *
+ * Returns undefined for every ordinary change, including a scaffolded one with
+ * no artifacts yet: only a *nested* change directory distinguishes the two.
+ */
+export declare function findNestedChangesIn(changesDir: string, name: string): Promise<NestedChangeFinding | undefined>;
+/**
+ * The same check across every candidate directory under `changes/`, for the
+ * commands that enumerate rather than resolve a single name.
+ */
+export declare function findNestedChanges(changesDir: string, names: string[]): Promise<NestedChangeFinding[]>;
+/**
+ * The stable phrase every nested-change diagnostic contains. Callers that have
+ * only the rendered message - `validate`'s next-steps, which branches on the
+ * exact issue it is advising about - recognise the case by this.
+ */
+export declare const NESTED_CHANGE_ISSUE_MARKER = "is not a change: it is a folder wrapping";
+/**
+ * The one explanation every surface prints, so the constraint and the way out
+ * read identically wherever a user meets them.
+ */
+export declare function describeNestedChange(finding: NestedChangeFinding): string;
+//# sourceMappingURL=nested-change.d.ts.map