@shibanet0/datamitsu-config 0.2.0 → 0.4.1

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

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

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/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/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/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 {};

package/dist/datamitsu-config/agents.md.d.ts

@@ -2,13 +2,13 @@ export declare const AGENTS_BASE: string;
 export declare const AGENTS_DOCS_MARKDOWN: string;
 export declare const AGENTS_DOCS_WEBSITE: string;
 export declare const CHUNK_00_BACKLOG_HASH = "8d8068ab184a1e2888d6fec12ef6e59fa172061cb712db734c42f7834a914209";
-export declare const CHUNK_00_BASE_HASH = "dc82caf6a6f273b7b87d967dc8ee3d46dadf7f02f02663bf15b9aae0a307bb25";
+export declare const CHUNK_00_BASE_HASH = "99f787a9542bbe75d2214c94b20525b3b85e1c0bd2c209d622b5416288058db4";
 export declare const CHUNK_00_CONFIG_INPUTS_HASH = "138dcb74fdd12336b8ccc87f1d589964996cc1e7d73f156b6870cb1ea6771542";
-export declare const CHUNK_00_DEPENDABOT_HASH = "b05aca84224760df0b9dae1f499a911c7c6531dd4623a7e55ab4d50b4f93f115";
-export declare const CHUNK_00_PRIVACY_HASH = "d8be582e591eb438952dd4173019ddb1f0f194260b04d1146526b6bd6afbd9f3";
+export declare const CHUNK_00_DEPENDABOT_HASH = "dcebf1f24d6a413ba1ae5dae29656d23a6b532c8e38d0e45409510a8441d285f";
+export declare const CHUNK_00_PRIVACY_HASH = "1ddad93a578148375649488c794902657f4542d55146687b2eb518cd3d2afe11";
 export declare const CHUNK_00_SCRIPTS_HASH = "2f7c6dcf065ff965f9f20b06768aad43fadadf0cad15f60bc72af10e750f1454";
-export declare const CHUNK_00_STACK_HASH = "bb04b25a48bec2084d5453936317e81529fdadd47d3b34e3d0c4cabcffebdb35";
+export declare const CHUNK_00_STACK_HASH = "0fc75a6d218f9bf4b31ac605f61373da5818d14cb282c33ad62e9a84db2be9a0";
 export declare const CHUNK_10_DOCS_HASH = "e4357d5d90b2f3e3f6cc982e821d3a76f92eee058311e7746ebb2937278a6d75";
-export declare const CHUNK_20_DOCS_MARKDOWN_HASH = "babafc853c28c64fc881f395c2a221a9639a1e34bfd8f219a50221e91e40dd05";
-export declare const CHUNK_20_DOCS_WEBSITE_HASH = "a9d1c1a59fa5b7ffd4c62819a84162113389675a4af72a7ab1e6eb0bfb325029";
+export declare const CHUNK_20_DOCS_MARKDOWN_HASH = "c966e49af479f77fc45d99b41dce062b873f3ab1af62c44ab5324b05374d505a";
+export declare const CHUNK_20_DOCS_WEBSITE_HASH = "c2e1ca1dd5e32d27e2f82955bbf703b3cb4c6e0b4d9427a78907e01844cb6dbf";
 export declare const ALL_AGENTS_HASHES: string[];

package/dist/datamitsu-config/alint-defaults.d.ts

@@ -0,0 +1,22 @@
+export declare const ALINT_MANAGED_FILE = "alint-managed.yml";
+export declare const ALINT_MANAGED_PATH = ".datamitsu/alint-managed.yml";
+interface NamingRule {
+    id: string;
+    message: string;
+    paths: string | {
+        exclude: string[];
+        include: string[];
+    };
+    pattern: string;
+}
+/**
+ * File-name conventions every project gets. They only forbid what no ecosystem uses: mixed
+ * separators, spaces, or a case its language rules out. JS/TS allows kebab-case, camelCase and
+ * PascalCase because front-end trees use all three (components, hooks, modules), plus the route
+ * syntax of file-based routers. A project narrows a rule by redefining its `id` in `.alint.yml`.
+ *
+ * Directory names are ls-lint's: alint has no directory-name rule kind.
+ */
+export declare const alintNamingRules: NamingRule[];
+export declare function buildManagedAlintYaml(): string;
+export {};

package/dist/datamitsu-config/apps/eslint.deps.d.ts

@@ -7,13 +7,14 @@ export declare const eslintDeps: {
     readonly "@eslint/js": string;
     readonly "@next/eslint-plugin-next": string;
     readonly "@stylistic/eslint-plugin": string;
+    readonly "@typescript-eslint/utils": string;
     readonly "@vitest/eslint-plugin": string;
+    readonly "caniuse-lite": string;
     readonly eslint: string;
     readonly "eslint-config-prettier": string;
     readonly "eslint-flat-config-utils": string;
     readonly "eslint-import-resolver-typescript": string;
     readonly "eslint-plugin-array-func": string;
-    readonly "eslint-plugin-arrow-return-style": string;
     readonly "eslint-plugin-baseline-js": string;
     readonly "eslint-plugin-boundaries": string;
     readonly "eslint-plugin-clsx": string;
@@ -50,9 +51,25 @@ export declare const eslintDeps: {
     readonly "eslint-plugin-security": string;
     readonly "eslint-plugin-sonarjs": string;
     readonly "eslint-plugin-storybook": string;
+    readonly "eslint-plugin-svelte": string;
     readonly "eslint-plugin-turbo": string;
     readonly "eslint-plugin-unicorn": string;
     readonly "eslint-plugin-unused-imports": string;
     readonly globals: string;
+    /**
+     * Not a plugin, and not optional either: `svelte-eslint-parser` declares `svelte` as a peer and
+     * loads `svelte/compiler` to parse a component. The managed app installs into the datamitsu
+     * store, where the consuming project's own `svelte` is not on the resolution path — so without
+     * this entry every `.svelte` file fails to parse in a project that has svelte installed. Pinned
+     * rather than left to `autoInstallPeers` so the compiler version is the one this config was
+     * tested against.
+     */
+    readonly svelte: string;
+    /**
+     * A dependency of `eslint-plugin-svelte` already. Pinned here as well because the plugin's own
+     * range is a caret, and the parser is what decides whether a component parses at all — a minor
+     * bump of it that nobody read is a change to the AST every svelte rule reads.
+     */
+    readonly "svelte-eslint-parser": string;
     readonly "typescript-eslint": string;
 };

package/dist/datamitsu-config/apps/lefthook-proxy.d.ts

@@ -0,0 +1 @@
+export declare const lefthookProxyApp: BinManager.App;

package/dist/datamitsu-config/apps/sort-keys.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Alphabetical key order for YAML and `.properties`, replacing the two `yq` invocations that did
+ * the same job and lost data doing it:
+ *
+ * - YAML. `sort_keys(..)` moved an alias above the anchor that defines it, and the document stopped
+ *   parsing. This one leaves any document carrying an anchor, an alias or a merge key exactly as it
+ *   is, and sorts the rest.
+ * - `.properties`. The round trip through YAML folded `a.b` into a nested `a` and dropped one of the
+ *   two keys. This one never parses values — it orders whole records as text.
+ *
+ * One app with the format as its first argument, rather than one app per format: the two sorters
+ * are fifty lines each and share their whole contract (idempotent, byte-stable,
+ * comment-preserving), so splitting them would duplicate the packaging and the tests without
+ * separating anything.
+ *
+ * The inline entrypoint resolves its external YAML parser from the managed app environment, the
+ * same way lefthook-sort does — the YAML side has to go through the `yaml` document AST, because
+ * that is what keeps every comment attached to the key it belongs to.
+ */
+export declare const sortKeysApp: BinManager.App;

package/dist/datamitsu-config/apps/stylelint.d.ts

@@ -0,0 +1 @@
+export declare const stylelintApp: BinManager.App;

package/dist/datamitsu-config/apps/stylelint.deps.d.ts

@@ -0,0 +1,16 @@
+export declare const stylelintDeps: {
+    /**
+     * Not a preset. `stylelint-config-html` declares it as a peer, and it is the custom syntax that
+     * extracts `<style>` out of html, vue and svelte — stylelint bundles a syntax for none of those.
+     */
+    readonly "postcss-html": string;
+    readonly stylelint: string;
+    readonly "stylelint-config-html": string;
+    readonly "stylelint-config-recommended-vue": string;
+    readonly "stylelint-config-standard": string;
+    /**
+     * Brings `postcss-scss` with it, which is what makes a `.scss` file parse at all — stylelint 17
+     * bundles no syntax but its own CSS parser.
+     */
+    readonly "stylelint-config-standard-scss": string;
+};

package/dist/datamitsu-config/cmd-managed-configs.d.ts

@@ -0,0 +1,2 @@
+export declare const managedConfigs: config.MapOfManagedConfigs;
+export declare const initCommands: config.MapOfInitCommands;

package/dist/datamitsu-config/gitleaks-defaults.d.ts

@@ -0,0 +1 @@
+export declare function buildManagedGitleaksToml(): string;

package/dist/datamitsu-config/globs.d.ts

@@ -1,9 +1,24 @@
 export declare const actionlintGlobs: string[];
+export declare const githubActionsGlobs: string[];
 export declare const dockerfileGlobs: string[];
 export declare const composeGlobs: string[];
+export declare const droastGlobs: string[];
 export declare const cargoGlobs: string[];
 export declare const goGlobs: string[];
+export declare const goSourceGlobs: string[];
+export declare const goFormatExcludeGlobs: string[];
 export declare const sqlGlobs: string[];
+/**
+ * What stylelint lints. Stylesheets, plus the three shapes that carry a `<style>` block — the
+ * overrides that attach `postcss-html` to those live in src/apps/stylelint/index.ts.
+ *
+ * `.less` is deliberately absent. stylelint 17 bundles no syntax but its own CSS parser, so a
+ * `.less` file needs `postcss-less` and a preset of its own, neither of which is adopted here — and
+ * pointing stylelint at one without them fails to parse rather than reporting nothing. oxfmt still
+ * formats `.less`; it is linting that is missing, and the gap is here rather than hidden behind a
+ * glob that cannot work.
+ */
+export declare const stylelintGlobs: string[];
 export declare const tyGlobs: string[];
 export declare const dotenvLinterGlobs: string[];
 export declare const eslintGlobs: string[];
@@ -15,12 +30,27 @@ export declare const jsonExcludeGlobs: string[];
 export declare const oxlintGlobs: string[];
 export declare const oxfmtGlobs: string[];
 export declare const packageJsonGlobs: string[];
+/**
+ * What changes a syncpack verdict. The manifests are the subject, but the workspace file decides
+ * which manifests there are — and in pnpm it also carries `catalog:` entries and `overrides`, so a
+ * version can move without a single `package.json` being touched. With only the manifests listed, a
+ * commit that edits the catalog alone skips the check that exists to notice.
+ */
+export declare const syncpackGlobs: string[];
 export declare const prettierGlobs: string[];
 export declare const propertiesGlobs: string[];
 export declare const protoGlobs: string[];
 export declare const shellGlobs: string[];
 export declare const tomlGlobs: string[];
-export declare const typescriptGlobs: string[];
+/**
+ * What changes a `tsc` verdict, which is more than the TypeScript files themselves: `tsconfig.json`
+ * decides the compiler options, the file set and the project references, so editing one is exactly
+ * the change most likely to break a build — and with only the source globs listed, selecting it
+ * alone ran nothing. `.tsx`/`.mts`/`.cts` are already covered above; `allowJs` projects are not,
+ * and are left out deliberately rather than handing every JavaScript repository a type-check
+ * trigger.
+ */
+export declare const tscGlobs: string[];
 export declare const typstGlobs: string[];
 export declare const yamlGlobs: string[];
 export declare const yamlExcludeGlobs: string[];

package/dist/datamitsu-config/inline-config/commitlint.d.ts

@@ -1 +1 @@
-export declare const data = "tar.br:G/8NIB6J6UaD/NHKlnxpS7eszTIFvJqaw+3it6v/M5UyDti6xiKt8rKDx+f/fvIH/cBDGsgm+OIuomwUjVGFKTROYA4tzuNbxPNEqaQTuH1/09pbUgARbEno+6CYCyLneyEQwV8dAg7aXxaRIQBlw3UNgWTyaCiF+XzluePI0vt7kPJy+JqTCTmFDB3E/fKU5mAlQdIYq97aajrU6HNGW9c8Xc3h+PiZKR2P+S6SIduqjW4X3x1v3m/BGovyoQEb+ZQjzMcQNnDCm1I/C7OSaREDsba//DvFflhXqSi/Xf7Vuaf8h+f+6cfDIVK5ie9tkwFB7GuvAOAS4S7V8YOflx2G9gE4s7RTRQUwAH3D5u7qbGaWVAYYKgDDkGpovRitXn2/qp5s+aQW8PveQQu7AaAwmIFPIhVUoVJSIQx+AxVsukEevqkf9H2v6azBGRW7cUjpCYbTmqpqoFLBsn1n1bDa7SqJI72Jq8fcX1EH13aLpqpiHTIaDZtcOlfQEQ516sfyGNUCjvXRfWZ/e7V1lqoA8YepuHIbFQ2tKnlyJsRJzfGiDtFAtamf2gGV0muRtM6QUhmYB9YY4bkIAgE=";
+export declare const data = "tar.br:G/8PIGZTZ1qrZVLpXw5JRbj9AacCgN0pjWVjpqt8rWKje7MHZZBIDgDjUciqCtMKrZ+N+vgOYzegiA3w3ma0jJyFQqPaarkMOnQ2oeXCZrlJFeK3rhUghcD2YCJmBFUYiq+vEIZWEeo7G54vbO45itD1vnJut7qHlwl5heLRyh53Zxd6K0mSJ6j0tsXXoSaXM7ZE5RnO9M/Hz46yy5nvii0UyapGH9v7QmbXq5Ud+9ihE68Uwg1+xXnzyaMNwRRrErNkxkG9trds48fg6UfKtaFOt13zuR1oS6zOy/K7BQORvm0vAHxGyHUVtVL699JqpRiQnDloVTFCGKD99sNFGsq0ABktYEgBhkmq+f+ft7+L6bco2fNJneBxPwotLCORBMofftK+hP27OGpUnQKyKUQHkmltEVT8P87ja52rNbR7fXSaXZkH3u9xWR8AgbeH6N/ZWTtvg9IQbXagI+oMJSpQj47ODooBRQP2wEtjuadgRiNqEvBB08IGE/C4kJvrUIyp40fQgwo2kYrghlvdm+ToYOK1R14y+a8oMhjTwQ0ZYwJMKRL99y+l5ORgDdCzI1RvHDleqJ9gc1g4QKBrNClnBePNEVFAMyYtFM+jvrZtdSwnEApXMRM7YiIpYTp7f7AnuLaEP42Q5/apkwJErmOX68GWXJmTwu5Rb+scMxNlIl73rbYHq+QBRzCRB4UkvCRGk2XHP8dgAA==";

package/dist/datamitsu-config/inline-config/cspell.d.ts

@@ -1 +1 @@
-export declare const data = "tar.br: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";
+export declare const data = "tar.br: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";