@shibanet0/datamitsu-config 0.1.7 → 0.4.1

package/dist/apps/knip/index.js

@@ -1,11 +1,210 @@
 //#region src/apps/knip/index.ts
-const baseConfig = {
-	entry: ["src/index.ts"],
-	project: ["src/**/*.ts"]
+const KNIP_DEFAULT_ENTRY = ["{index,cli,main}.{js,mjs,cjs,jsx,ts,tsx,mts,cts}!", "src/{index,cli,main}.{js,mjs,cjs,jsx,ts,tsx,mts,cts}!"];
+const PROJECT_SCOPED_CONFIGS = [
+	"eslint.config.mjs",
+	"oxlint.config.mts",
+	"prettier.config.mjs"
+];
+const GIT_ROOT_SCOPED_CONFIGS = [
+	".markdownlint-cli2.mjs",
+	"commitlint.config.mjs",
+	"cspell.config.mjs",
+	"datamitsu.config.{js,ts}",
+	"knip.config.js",
+	"oxfmt.config.ts"
+];
+const ROOT_WORKSPACE_NAME = ".";
+const SHARED_WORKSPACE_KEY = "**";
+/**
+* Options knip reads _only_ from the workspace config, so the root loses them the moment
+* `workspaces` exists — see {@link withRootWorkspace}.
+*
+* Deliberately shorter than the set of options that can appear in a workspace block. `ignore` and
+* `ignoreFiles` are registered globally from the top-level config as well, and
+* `ignoreExportsUsedInFile` and `includeEntryExports` are read as `workspaceConfig.x ?? topLevel.x`
+* — moving either kind under `"."` would turn a global default into a root-only one.
+*/
+const WORKSPACE_SCOPED_OPTIONS = [
+	"entry",
+	"ignoreMembers",
+	"paths",
+	"project"
+];
+/**
+* What a finding says:
+*
+* - `correctness` — real defects: an import that does not resolve, a dependency used but never
+*   declared, a module exporting the same value twice.
+* - `cycles` — circular imports. A real defect class, and one of the two groups off by default — not
+*   because the findings are weak but because reaching them is expensive. knip withholds this type
+*   from its own default set, and the only lever that brings it back, `include`, is merged with the
+*   command line's, so a config carrying one defeats `--files`, `--exports` and `--dependencies`
+*   for every later run. Adopt it where the trade is worth making.
+* - `dependencies` — declared but never used. Needs `ignoreDependencies` for tools a config loads by
+*   name.
+* - `exports` — unused exports and types. The largest group in a library monorepo.
+* - `files` — unreachable files. Only as true as the entry graph, so it needs the plugins right.
+* - `namespaces` — exports reachable only through an `import * as`. Off by default, and the one group
+*   that stays off: knip cannot tell whether these are used, so the finding is not "this is dead"
+*   but "restructure your imports so I can see". That is a style position, not a defect.
+*
+* This is also every value {@link DefineConfigOptions.adopted} accepts.
+*/
+const ISSUE_GROUPS = [
+	"correctness",
+	"cycles",
+	"dependencies",
+	"exports",
+	"files",
+	"namespaces"
+];
+/**
+* Every knip issue type, and the group that owns it.
+*
+* `satisfies Record<IssueType, IssueGroup>` is the point: a knip upgrade that adds an issue type
+* stops this file compiling until somebody decides which group it belongs to. Without it the new
+* type would simply be absent from the emitted `rules` and fall back to knip's own default — the
+* kind of residual with no author behind it that `src/lint-rules` exists to prevent.
+*/
+const ISSUE_TYPE_GROUPS = {
+	binaries: "correctness",
+	catalog: "dependencies",
+	catalogReferences: "correctness",
+	cycles: "cycles",
+	dependencies: "dependencies",
+	devDependencies: "dependencies",
+	duplicates: "correctness",
+	enumMembers: "exports",
+	exports: "exports",
+	files: "files",
+	namespaceMembers: "exports",
+	nsExports: "namespaces",
+	nsTypes: "namespaces",
+	optionalPeerDependencies: "dependencies",
+	types: "exports",
+	unlisted: "correctness",
+	unresolved: "correctness"
 };
-const defineConfig = (overrides) => typeof overrides === "function" ? overrides(baseConfig) : {
-	...baseConfig,
-	...overrides
+const ISSUE_TYPES = Object.keys(ISSUE_TYPE_GROUPS);
+const ADOPTED_BY_DEFAULT = [
+	"correctness",
+	"dependencies",
+	"exports",
+	"files"
+];
+const EXCLUDED_BY_KNIP = /* @__PURE__ */ new Set([
+	"cycles",
+	"nsExports",
+	"nsTypes"
+]);
+const DEPENDENCY_TYPES_COUPLED_TO_DEPENDENCIES = ["devDependencies", "optionalPeerDependencies"];
+const createBaseConfig = () => ({
+	entry: [
+		...KNIP_DEFAULT_ENTRY,
+		...PROJECT_SCOPED_CONFIGS,
+		...GIT_ROOT_SCOPED_CONFIGS
+	],
+	ignoreBinaries: [
+		"datamitsu",
+		"dm",
+		"s0"
+	],
+	tags: ["-knipignore"],
+	workspaces: { [SHARED_WORKSPACE_KEY]: { entry: [...KNIP_DEFAULT_ENTRY, ...PROJECT_SCOPED_CONFIGS] } }
+});
+const rulesFor = (adopted, overrides, explicit) => {
+	const reported = new Set(adopted);
+	const rules = Object.fromEntries(ISSUE_TYPES.map((issueType) => {
+		const override = overrides?.[issueType];
+		if (override !== void 0) return [issueType, override === "off" ? "off" : "error"];
+		return [issueType, reported.has(ISSUE_TYPE_GROUPS[issueType]) ? "error" : "off"];
+	}));
+	if (rules.dependencies === "off") {
+		const demanded = DEPENDENCY_TYPES_COUPLED_TO_DEPENDENCIES.filter((issueType) => explicit?.[issueType] === "error");
+		if (demanded.length > 0) throw new Error(`knip cannot report ${demanded.join(" or ")} while \`dependencies\` is off: turning \`dependencies\` off excludes them too, and an exclusion cannot be undone by an include. Drop the \`dependencies: "off"\`, or drop these.`);
+		for (const issueType of DEPENDENCY_TYPES_COUPLED_TO_DEPENDENCIES) rules[issueType] = "off";
+	}
+	return rules;
+};
+/**
+* The `include` list knip needs, or `undefined` when its own default set already covers what is
+* reported.
+*
+* Severities are not the lever for turning an issue type **on**: knip feeds the types set to `off`
+* into its `exclude` and never reads severities into its `include`, so a type it leaves out of its
+* default set stays out however loudly `rules` asks for it. Naming one in `include` then replaces
+* that default set wholesale — listing only `cycles` reports _nothing but_ cycles — so the list has
+* to be every reported type, not just the ones knip omits.
+*
+* Which is why nothing this emits is on by default. knip **unions** a config's `include` with the
+* command line's, so a config carrying one makes `--files`, `--exports`, `--dependencies` and
+* `--include <type>` stop narrowing anything: the union is still every reported type, and a run
+* meant to look at one kind of finding fails on the other fourteen. That is the whole cost of
+* adopting `cycles` or `namespaces`, and it lands on `datamitsu exec knip`, which is the only way
+* these findings are read by a person. `--exclude` still narrows; it is applied last and wins.
+*/
+const includeFor = (rules) => {
+	const reported = ISSUE_TYPES.filter((issueType) => rules?.[issueType] === "error");
+	return reported.some((issueType) => EXCLUDED_BY_KNIP.has(issueType)) ? reported : void 0;
+};
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const mergeValue = (current, value) => {
+	if (value === void 0) return current;
+	if (Array.isArray(current) && Array.isArray(value)) return [...current, ...value];
+	if (isPlainObject(current) && isPlainObject(value)) {
+		const merged = { ...current };
+		for (const [key, nested] of Object.entries(value)) merged[key] = mergeValue(merged[key], nested);
+		return merged;
+	}
+	return value;
+};
+const mergeConfig = (base, overrides) => mergeValue(base, overrides);
+const withSharedWorkspaceDefaults = (config) => {
+	const workspaces = config.workspaces;
+	const shared = workspaces?.[SHARED_WORKSPACE_KEY];
+	if (!workspaces || !shared) return config;
+	return {
+		...config,
+		workspaces: Object.fromEntries(Object.entries(workspaces).map(([key, value]) => key === SHARED_WORKSPACE_KEY || key === ROOT_WORKSPACE_NAME ? [key, value] : [key, mergeValue(shared, value)]))
+	};
+};
+const withRootWorkspace = (config) => {
+	const rest = { ...config };
+	const moved = {};
+	for (const option of WORKSPACE_SCOPED_OPTIONS) {
+		if (!(option in rest)) continue;
+		moved[option] = rest[option];
+		delete rest[option];
+	}
+	if (Object.keys(moved).length === 0) return config;
+	const workspaces = rest["workspaces"] ?? {};
+	return {
+		...rest,
+		workspaces: {
+			...workspaces,
+			[ROOT_WORKSPACE_NAME]: {
+				...moved,
+				...workspaces[ROOT_WORKSPACE_NAME]
+			}
+		}
+	};
+};
+const defineConfig = (overrides, options) => {
+	const adopted = options?.adopted ?? ADOPTED_BY_DEFAULT;
+	const baseRules = rulesFor(adopted);
+	const base = {
+		...createBaseConfig(),
+		rules: baseRules
+	};
+	const merged = typeof overrides === "function" ? overrides(base) : overrides ? mergeConfig(base, overrides) : base;
+	const explicitRules = typeof overrides === "function" || !overrides ? Object.fromEntries(Object.entries(merged.rules ?? {}).filter(([issueType, severity]) => severity !== baseRules[issueType])) : overrides.rules;
+	const rules = rulesFor(adopted, merged.rules, explicitRules);
+	const include = merged.include ?? includeFor(rules);
+	return withRootWorkspace(withSharedWorkspaceDefaults({
+		...merged,
+		...include && { include },
+		rules
+	}));
 };
 //#endregion
-export { defineConfig };
+export { ISSUE_GROUPS, defineConfig };

package/dist/apps/lefthook-proxy/__tests__/env.d.ts

@@ -0,0 +1,2 @@
+export { fixtureEnvironment } from "../../test-support/env";
+export declare function testUpstream(managedEnvironment: NodeJS.ProcessEnv): string | undefined;

package/dist/apps/lefthook-proxy/__tests__/fixtures/fake-upstream.d.mts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/apps/lefthook-proxy/env.d.ts

@@ -0,0 +1,15 @@
+export interface ProxyEnvironment {
+    active: boolean;
+    gitIndexFile?: string;
+    noColor: boolean;
+    path: string;
+    pathExtensions: string;
+    publicProxy?: string;
+    upstream?: string;
+}
+export declare function childEnvironment(markActive: boolean): NodeJS.ProcessEnv;
+export declare function hookRuntimeSettings(): {
+    directory: string;
+    options: string;
+};
+export declare function proxyEnvironment(source?: NodeJS.ProcessEnv): ProxyEnvironment;

package/dist/apps/lefthook-proxy/exit-codes.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Exit codes the proxy adds on top of whatever upstream Lefthook returns. They start at the
+ * sysexits.h range so they cannot be confused with a Lefthook command's own non-zero status.
+ */
+/**
+ * The working tree could not be isolated, or could not be restored afterwards. Nothing was lost —
+ * the transaction stash is retained and the recovery commands are printed — but the tree may be
+ * missing the hidden changes until the backup is applied.
+ */
+export declare const restoreFailureExitCode = 70;
+/**
+ * The working tree is intact, but the installed Git hooks could not be re-pointed at the public
+ * proxy. Hooks keep working; they just may call upstream Lefthook directly until the next
+ * successful `lefthook install`, which means the next commit can run without isolation.
+ */
+export declare const hookBindingFailureExitCode = 71;
+/**
+ * Upstream Lefthook could not be found or could not be executed at all.
+ */
+export declare const upstreamMissingExitCode = 127;

package/dist/apps/lefthook-proxy/git.d.ts

@@ -0,0 +1,16 @@
+export interface StashEntry {
+    oid: string;
+    selector: string;
+    subject: string;
+}
+export declare function gitCommand(args: readonly string[], input?: Buffer): Promise<Buffer>;
+export declare function gitDirectory(repositoryRootPath: string): Promise<string>;
+export declare function gitOutput(args: readonly string[]): Promise<string>;
+export declare function listStashes(repositoryRootPath: string): Promise<StashEntry[]>;
+export declare function nulSeparatedPaths(paths: Buffer): Buffer[];
+/**
+ * Name of the in-flight Git operation (merge, rebase, …), if the repository is mid-operation.
+ */
+export declare function operationInProgress(directory: string): string | undefined;
+export declare function repositoryHasHead(repositoryRootPath: string): Promise<boolean>;
+export declare function repositoryRoot(): Promise<string>;

package/dist/apps/lefthook-proxy/hooks.d.ts

@@ -0,0 +1 @@
+export declare function bindInstalledHooksToProxy(publicProxy: string, upstream: string): Promise<number>;

package/dist/apps/lefthook-proxy/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/apps/lefthook-proxy/isolation-failure-error.d.ts

@@ -0,0 +1,13 @@
+export type IsolationTarget = "head" | "index";
+export interface StashTransaction {
+    marker: string;
+    oid: string;
+    repositoryRoot: string;
+    target: IsolationTarget;
+}
+export declare class IsolationFailureError extends Error {
+    readonly marker: string;
+    readonly repositoryRoot: string;
+    readonly transaction: StashTransaction | undefined;
+    constructor(message: string, marker: string, repositoryRoot: string, transaction?: StashTransaction);
+}

package/dist/apps/lefthook-proxy/isolation.d.ts

@@ -0,0 +1,5 @@
+import type { ProxyEnvironment } from "./env.js";
+import { type IsolationTarget, type StashTransaction } from "./isolation-failure-error.js";
+export declare function isolateWorkingTree(target: IsolationTarget, environment: ProxyEnvironment): Promise<StashTransaction | undefined>;
+export declare function isolationTarget(args: readonly string[]): IsolationTarget | undefined;
+export declare function restoreTransaction(transaction: StashTransaction): Promise<void>;

package/dist/apps/lefthook-proxy/messages.d.ts

@@ -0,0 +1,5 @@
+import type { StashTransaction } from "./isolation-failure-error.js";
+export declare function errorMessage(error: unknown): string;
+export declare function writeError(message: string): void;
+export declare function writeProxyNotice(): void;
+export declare function writeRecovery(transaction: StashTransaction): void;

package/dist/apps/lefthook-proxy/resolve.d.ts

@@ -0,0 +1,3 @@
+import { type ProxyEnvironment } from "./env.js";
+export declare function resolvePublicProxy(environment?: ProxyEnvironment): string;
+export declare function resolveUpstream(environment?: ProxyEnvironment): string;

package/dist/apps/lefthook-proxy/signals.d.ts

@@ -0,0 +1,19 @@
+import type { ChildProcess } from "node:child_process";
+export interface ChildResult {
+    code: number;
+    error?: Error;
+}
+export type RelaySignal = "SIGHUP" | "SIGINT" | "SIGTERM";
+export declare const signalExitCodes: Record<RelaySignal, number>;
+export declare class SignalRelay {
+    private child;
+    private readonly handlers;
+    private received;
+    constructor();
+    lastSignal(): RelaySignal | undefined;
+    setChild(child?: ChildProcess): void;
+    start(): void;
+    stop(): void;
+    private forward;
+}
+export declare function resultForSignal(signal: NodeJS.Signals | null): ChildResult;

package/dist/apps/lefthook-sort/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/apps/lefthook-sort/sort.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Reorder the `commands:` map of every hook in a lefthook config. Returns the rewritten YAML; a
+ * document already in canonical order round-trips unchanged.
+ */
+export declare function sortDocument(source: string): string;

package/dist/apps/markdownlint-cli2/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Markdown gets a structural linter, not a second formatter.
+ *
+ * Oxfmt owns how a Markdown file looks — and it owns the fenced code inside it too: measured on a
+ * file holding thirteen languages, it reformats `js`, `ts`, `tsx`, `json`, `css`, `yaml` and
+ * `graphql` blocks, byte-identical to what prettier writes. What no formatter reports is the
+ * structure: a fence with no language, a bare URL, a heading level that skips a step, a link whose
+ * fragment does not exist, a table whose rows disagree on column count. That is the whole job here
+ * — 42 findings on this repository's 45 Markdown files, none of which any other tool in the
+ * toolchain reports.
+ *
+ * Every rule that decides what the file _looks_ like is therefore off, and the list below says
+ * which of two reasons put it there. Leaving one on does not produce a second opinion, it produces
+ * a loop: the formatter writes its form, the linter reports it, and `dm check` fails on a file `dm
+ * fix` has just written.
+ *
+ * The types are written here rather than imported from the package. markdownlint-cli2 is a managed
+ * binary, not a dependency of this repository or of a consuming project, so there is nothing to
+ * import them from at build time — and pulling the package in as a devDependency to type a config
+ * object of six keys is a poor trade.
+ */
+/**
+ * The markdownlint-cli2 configuration object — the shape a `.markdownlint-cli2.mjs` exports.
+ */
+export interface Config {
+    config?: MarkdownlintConfig;
+    customRules?: string[];
+    fix?: boolean;
+    frontMatter?: string;
+    gitignore?: boolean;
+    globs?: string[];
+    ignores?: string[];
+    markdownItPlugins?: unknown[];
+    modulePaths?: string[];
+    noBanner?: boolean;
+    noProgress?: boolean;
+    outputFormatters?: unknown[];
+    showFound?: boolean;
+}
+/**
+ * The `config` object: markdownlint's own rule configuration.
+ */
+export interface MarkdownlintConfig {
+    [rule: string]: null | RuleConfig | string | undefined;
+    default?: boolean;
+    extends?: null | string;
+}
+/**
+ * A markdownlint rule: off, on, or on with options.
+ */
+export type RuleConfig = boolean | Record<string, unknown>;
+/**
+ * Merges one level deep, so `defineConfig({ config: { MD041: false } })` keeps the rule decisions
+ * above instead of replacing all of them with that one entry — the failure mode documented for
+ * oxlint, stylelint and oxfmt in AGENTS.md, and the one anyone writing this call would hit first.
+ * Replacing wholesale is the function form, where `base` is in hand.
+ */
+export declare const defineConfig: (config?: ((base: Config) => Config) | Config) => Config;

package/dist/apps/oxfmt/index.d.ts

@@ -1,3 +1,13 @@
 import { type OxfmtConfig } from "oxfmt";
 export type { OxfmtConfig } from "oxfmt";
-export declare const defineConfig: (config?: OxfmtConfig) => OxfmtConfig;
+/**
+ * Accepts an overrides object, shallow-merged over the base, or a function that receives the base
+ * and returns the final config — the latter is how a project extends `overrides` instead of
+ * replacing it:
+ *
+ *     export default defineConfig((base) => ({
+ *       ...base,
+ *       overrides: [...(base.overrides ?? []), { files: ["*.md"], options: { printWidth: 80 } }],
+ *     }));
+ */
+export declare const defineConfig: (config?: ((base: OxfmtConfig) => OxfmtConfig) | OxfmtConfig) => OxfmtConfig;

package/dist/apps/oxlint/__tests__/index.test.d.ts

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

package/dist/apps/oxlint/index.d.ts

@@ -1,2 +1,90 @@
 import type { Oxlintrc } from "./schema";
+export type { Oxlintrc } from "./schema";
+/**
+ * The part of a `package.json` this config reads.
+ *
+ * Deliberately narrower than type-fest's `PackageJson`, which is what the ESLint half takes: a
+ * `with { type: "json" }` import hands TypeScript the literal shape of the consumer's own manifest,
+ * and the wide type does not always accept it — `exports` and `bin` are the usual casualties. Every
+ * real manifest satisfies this one, and it says exactly what is looked at.
+ */
+export interface OxlintPackageJson {
+    dependencies?: Partial<Record<string, string>> | undefined;
+    devDependencies?: Partial<Record<string, string>> | undefined;
+    optionalDependencies?: Partial<Record<string, string>> | undefined;
+    peerDependencies?: Partial<Record<string, string>> | undefined;
+}
+/**
+ * The oxlint half of the shared lint configuration.
+ *
+ * Every category is on, including `restriction` — which, unlike the others, is not a quality bar
+ * but a bag of project-specific bans that oxlint expects you to opt into one rule at a time.
+ * Turning it on lights up every rule at once, so the ones this stack does not want are turned off
+ * by name in `src/lint-rules` rather than by leaving the category off. A project that wants the
+ * backlog rules back on re-enables them in its own `.oxlintrc.json`, which extends this one.
+ *
+ * That list is shared with ESLint on purpose. `eslint-plugin-oxlint` suppresses an ESLint rule only
+ * while oxlint is _reporting_ the equivalent, so turning a rule off here used to hand it straight
+ * back to ESLint — the same finding, same file, still failing, now under a different rule name.
+ * Feeding both tools the same list is what stops that.
+ *
+ * No `$schema`: this is consumed as a TypeScript module, where the `Oxlintrc` type does the job a
+ * JSON schema reference used to.
+ */
 export declare const oxlintConfig: Oxlintrc;
+/**
+ * Options a consumer's `oxlint.config.mts` can pass, mirroring the ESLint half's.
+ */
+export interface OxlintDefineConfigOptions {
+    /**
+     * Apply the shared migration backlog — the rules in `src/lint-rules/temporary` that should be on
+     * and are off only until the code is ready for them. Defaults to `true`.
+     *
+     * The ESLint half has had this since it was written; oxlint's did not, because
+     * `disabledRulesForOxlint()` was called with no arguments at module scope and `defineConfig` had
+     * nowhere to put an option. So `defineConfig(pkg, config, { temporaryRules: false })` raised the
+     * bar in ESLint while oxlint kept every backlog rule off — and since `eslint-plugin-oxlint`
+     * suppresses whatever oxlint reports, the documented "we are already clean, opt out" path made
+     * the config quieter in the one place it claimed to make it stricter.
+     */
+    temporaryRules?: boolean | undefined;
+}
+/**
+ * {@link oxlintConfig} narrowed to a project: framework plugins it does not depend on removed, and
+ * the migration backlog dropped if it opted out.
+ *
+ * Exported so the ESLint half can build its `eslint-plugin-oxlint` suppressions from the same
+ * config the project's oxlint run uses. That plugin turns an ESLint rule off on the premise that
+ * oxlint is reporting the equivalent — so handing it a config claiming plugins the project does not
+ * have, or turn-offs the project opted out of, would suppress rules nothing reports.
+ */
+export declare function oxlintConfigFor(packageJSON?: OxlintPackageJson, options?: OxlintDefineConfigOptions): Oxlintrc;
+/**
+ * The entry point a consumer's `oxlint.config.mts` calls.
+ *
+ * Takes the project's `package.json` first, the way the ESLint half's `defineConfig` does and for
+ * the same reason: which framework plugins run is a question about the project, and the manifest is
+ * the only place the answer is written down. Passing nothing keeps every plugin, so a config
+ * generated before this parameter existed behaves as it did.
+ *
+ * Then either an overrides object, shallow-merged over the base, or a function that receives the
+ * base and returns the final config — the latter for extending an array or object field instead of
+ * replacing it:
+ *
+ * ```ts
+ * export default defineConfig(packageJSON, (base) => ({
+ *   ...base,
+ *   overrides: [...(base.overrides ?? []), { files: ["src/legacy/**"], rules: { … } }],
+ * }));
+ * ```
+ *
+ * The object form adds to the base rather than replacing the keys it names — see
+ * {@link mergeConfig}. The function form is what to reach for when the base genuinely has to be
+ * replaced or reordered.
+ *
+ * This is what a JSON config could not do. `extends` in a JSON config carries `rules`, `plugins`
+ * and `overrides` and silently drops `env`, `globals`, `settings`, `ignorePatterns` and `options`,
+ * so half of what this file decides never reached the project that extended it. Composing objects
+ * in JS has nothing to drop.
+ */
+export declare const defineConfig: (packageJSON?: OxlintPackageJson, config?: ((base: Oxlintrc) => Oxlintrc) | Oxlintrc, options?: OxlintDefineConfigOptions) => Oxlintrc;

package/dist/apps/oxlint/plugins.generated.d.ts

@@ -0,0 +1,15 @@
+import type { LintPluginOptionsSchema } from "./schema";
+export declare const OXLINT_PLUGINS: readonly ["eslint", "import", "jsdoc", "jsx-a11y", "nextjs", "node", "oxc", "promise", "react", "react-perf", "typescript", "unicorn", "vitest", "vue"];
+/**
+ * Plugins deliberately left off. The reasons live in scripts/generate-oxlint-plugins.ts; they are
+ * exported so the inventory validator can tell a decision apart from an oversight.
+ */
+export declare const OXLINT_EXCLUDED_PLUGINS: readonly ["jest"];
+/**
+ * Fails the typecheck if a plugin is neither enabled nor deliberately excluded — including one the
+ * next oxlint bump adds. Dropping a plugin from the array by hand is a compile error rather than a
+ * quietly narrower lint.
+ */
+export type _EveryOxlintPluginIsAccountedFor = AssertNever<Exclude<LintPluginOptionsSchema, (typeof OXLINT_EXCLUDED_PLUGINS)[number] | (typeof OXLINT_PLUGINS)[number]>>;
+type AssertNever<T extends never> = T;
+export {};

package/dist/apps/sort-keys/__tests__/sort.test.d.ts

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

package/dist/apps/sort-keys/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/apps/sort-keys/properties.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Alphabetical key sorting for `.properties`, done on the text rather than through a data model.
+ *
+ * The previous sorter piped the file through YAML (`yq -p props -o props 'sort_keys(..)'`), and
+ * that round trip is lossy: YAML reads `a.b` as `b` nested under `a`, so a file holding both
+ * `a.b=hello` and `a=world` came back as `a = world` alone — one line silently gone. Java
+ * properties has no nesting; a dot is an ordinary character in a key.
+ *
+ * So nothing here parses values. A record is "whatever comment and blank lines precede a key line,
+ * plus that key line and its continuations", records are ordered by key, and every byte of each
+ * record is written back untouched. What cannot be lost this way: escapes, duplicate keys, unicode
+ * escapes, `:` or space as the separator, trailing whitespace inside a value.
+ */
+/**
+ * Returns the file with its records ordered by key, or the original text when there is nothing to
+ * reorder. Trailing comments and blank lines — the ones that follow the last key — stay at the end,
+ * where their author put them.
+ */
+export declare const sortProperties: (source: string) => string;

package/dist/apps/sort-keys/yaml.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns the sorted document, or the original text when sorting would be unsafe or would change
+ * nothing. Unsafe means: it does not parse, or it uses anchors, aliases or merge keys.
+ */
+export declare const sortYaml: (source: string) => string;

package/dist/apps/stylelint/__tests__/merge.test.d.ts

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

package/dist/apps/stylelint/index.d.ts

@@ -0,0 +1,13 @@
+import type { Config } from "stylelint";
+export type { Config } from "stylelint";
+/**
+ * Accepts an overrides object — added to the base rather than replacing the keys it names, see
+ * {@link mergeConfig} — or a function that receives the base and returns the final config, which is
+ * how a project replaces wholesale:
+ *
+ *     export default defineConfig((base) => ({
+ *       ...base,
+ *       rules: { ...base.rules, "selector-class-pattern": null },
+ *     }));
+ */
+export declare const defineConfig: (config?: ((base: Config) => Config) | Config) => Config;

package/dist/apps/stylelint/merge.d.ts

@@ -0,0 +1,21 @@
+import type { Config } from "stylelint";
+/**
+ * Adds the caller's config to the base instead of replacing the keys it names — the same decision,
+ * for the same reason, as `src/apps/oxlint/index.ts`.
+ *
+ * A spread was the obvious implementation and the wrong one. Everything that makes a component
+ * parse lives in `overrides`, so `defineConfig({ overrides: [{ files: ["*.css"], rules: … }] })` —
+ * the shape anyone would write to adjust one file type — dropped the `postcss-html` wiring along
+ * with it. Measured: `.svelte` then fails with `Unknown word <script>`, `.vue` with `Unknown word
+ * </style>`, and `.scss` with `Invalid double-slash CSS comment`. A config that silences a rule
+ * should not silently stop parsing three languages.
+ *
+ * Objects merge key by key, arrays append, and the caller still wins wherever they name the same
+ * key — `extends` and `overrides` are ordered last-wins in stylelint, so appending is what makes
+ * the caller's entry decide. Replacing wholesale is the function form of `defineConfig`.
+ *
+ * It lives in its own module so the merge can be tested without resolving the presets: `index.ts`
+ * turns every preset name into an absolute path in the managed app's install, which exists where
+ * stylelint runs and not in this repository.
+ */
+export declare function mergeConfig(base: Config, config?: Config): Config;

package/dist/apps/test-support/env.d.ts

@@ -0,0 +1 @@
+export declare function fixtureEnvironment(overrides?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;

package/dist/apps/test-support/managed-bun.d.ts

@@ -0,0 +1,6 @@
+export declare function installedBunApp(name: string): {
+    artifact: string;
+    command: string;
+    environment: NodeJS.ProcessEnv;
+    runtimeArgs: string[];
+};

package/dist/datamitsu-config/__tests__/agents-upgrade.test.d.ts

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

package/dist/datamitsu-config/__tests__/tool-config-paths.test.d.ts

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