@dogsbay/detect 0.0.0-stage → 0.2.0-beta.132

package/README.md

@@ -1,3 +1,28 @@
-# Temporary Holding Version
+# @dogsbay/detect
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Which documentation tool made a folder, from its file paths alone. No Node, no dependencies:
+it runs in a browser on a repository's tree before any importer is loaded.
+
+```ts
+import { detect, FORMAT_ORDER } from "@dogsbay/detect";
+
+detect(["README.md", "docs/gitbook/SUMMARY.md", "docs/gitbook/.gitbook/assets/a.png", …]);
+// { format: "gitbook", root: "docs/gitbook", confidence: "high", pages: 158, fidelity: "full" }
+```
+
+- `FORMAT_ORDER` is the import formats' detection precedence. The `dogsbay` CLI builds its
+  format registry in this order, so a folder is the same format in the CLI and in the browser.
+- `detect(paths, read?)` runs the path detectors in that order. `read` may supply a small
+  config file (`.gitbook.yaml`) by path.
+- A detection names the corpus `root`, how sure it is, how many pages it would convert, the
+  choices to offer (`spaces`, `versions`, `locales`) and whether the browser converts with
+  less fidelity than the CLI.
+
+Path detectors so far: GitBook and VitePress (`.vitepress/config.*` or
+`.vitepress/config/index.*`, outside `node_modules`; the shallowest project wins, then `docs/`,
+`site/`, `website/`). Other formats are detected on disk by the CLI, in the same order, until
+their browser import lands.
+
+## License
+
+MIT

package/dist/gitbook.d.ts

@@ -0,0 +1,24 @@
+/**
+ * GitBook (Git Sync) from paths. A folder holding `SUMMARY.md` or `.gitbook.yaml` is a space;
+ * a folder with no marker whose subfolders are spaces is a multi-space repo (snyk/user-docs).
+ * `@dogsbay/format-gitbook` reads the same rules: its importer through `gitbookVisible` and
+ * `gitbookSpaces`, its CLI detector through `detectGitbook` over a folder's top two levels.
+ */
+import type { Detection, ReadText } from "./types.js";
+/**
+ * Does GitBook read this path? Not under `node_modules`, and not under a hidden folder other
+ * than `.gitbook` (assets and includes live there). Hidden FILES are kept: `.gitbook.yaml`.
+ */
+export declare function gitbookVisible(path: string): boolean;
+/**
+ * The spaces under `root` (paths relative to it): `["."]` when `root` itself has a marker,
+ * else every direct subfolder with a SUMMARY.md, else none. A nested SUMMARY.md under a
+ * space is NOT a second space (review #8 of the CLI importer).
+ */
+export declare function gitbookSpaces(paths: string[]): string[];
+/**
+ * Find a GitBook corpus among `paths` (a repo's whole tree, or one folder's listing). The
+ * shallowest marker folders win; several at that depth under one parent are that parent's
+ * spaces. `read` (optional) supplies `.gitbook.yaml` so a relocated `root:` is counted.
+ */
+export declare function detectGitbook(paths: string[], read?: ReadText): Detection | undefined;

package/dist/gitbook.js

@@ -0,0 +1,130 @@
+import { depthOf, dirOf, joinPath, normalizePath, within } from "./paths.js";
+/**
+ * Does GitBook read this path? Not under `node_modules`, and not under a hidden folder other
+ * than `.gitbook` (assets and includes live there). Hidden FILES are kept: `.gitbook.yaml`.
+ */
+export function gitbookVisible(path) {
+    const segs = path.split("/");
+    for (let i = 0; i < segs.length; i++) {
+        const s = segs[i];
+        if (s === "node_modules")
+            return false;
+        if (i < segs.length - 1 && s.startsWith(".") && s !== ".gitbook")
+            return false;
+    }
+    return true;
+}
+const MARKERS = new Set(["SUMMARY.md", ".gitbook.yaml"]);
+/** Folders holding a GitBook marker, outside `.gitbook/` and mdBook projects. */
+function markerDirs(paths) {
+    const all = new Set(paths);
+    const dirs = new Set();
+    for (const p of paths) {
+        if (!gitbookVisible(p))
+            continue;
+        const name = p.slice(p.lastIndexOf("/") + 1);
+        if (!MARKERS.has(name))
+            continue;
+        const dir = dirOf(p);
+        if (dir.split("/").includes(".gitbook"))
+            continue;
+        // mdBook writes src/SUMMARY.md with book.toml beside src/: not GitBook
+        if (all.has(joinPath(dir, "book.toml")) || all.has(joinPath(dirOf(dir), "book.toml")))
+            continue;
+        dirs.add(dir);
+    }
+    return [...dirs].sort();
+}
+/**
+ * The spaces under `root` (paths relative to it): `["."]` when `root` itself has a marker,
+ * else every direct subfolder with a SUMMARY.md, else none. A nested SUMMARY.md under a
+ * space is NOT a second space (review #8 of the CLI importer).
+ */
+export function gitbookSpaces(paths) {
+    const all = new Set(paths.filter(gitbookVisible));
+    if (all.has("SUMMARY.md") || all.has(".gitbook.yaml"))
+        return ["."];
+    const out = new Set();
+    for (const p of all) {
+        const m = /^([^/]+)\/SUMMARY\.md$/.exec(p);
+        if (m && !m[1].startsWith(".") && m[1] !== "node_modules")
+            out.add(m[1]);
+    }
+    return [...out].sort();
+}
+/**
+ * `root:` in a `.gitbook.yaml`, read without a YAML parser (detection must stay tiny). Plain
+ * string work, no backtracking regex: the file is someone else's, and a lazy group between two
+ * whitespace runs took 34 s on 4 KB of spaces.
+ */
+function configRoot(text) {
+    if (!text)
+        return "";
+    for (const line of text.slice(0, 65536).split("\n")) {
+        if (!line.startsWith("root:"))
+            continue;
+        let v = line.slice(5);
+        const hash = v.indexOf("#");
+        if (hash >= 0)
+            v = v.slice(0, hash);
+        v = v.trim();
+        if (v.length >= 2 && (v[0] === '"' || v[0] === "'") && v[v.length - 1] === v[0])
+            v = v.slice(1, -1).trim();
+        return normalizePath(v) ?? "";
+    }
+    return "";
+}
+/**
+ * Find a GitBook corpus among `paths` (a repo's whole tree, or one folder's listing). The
+ * shallowest marker folders win; several at that depth under one parent are that parent's
+ * spaces. `read` (optional) supplies `.gitbook.yaml` so a relocated `root:` is counted.
+ */
+export function detectGitbook(paths, read) {
+    const markers = markerDirs(paths);
+    if (!markers.length)
+        return undefined;
+    const depth = Math.min(...markers.map(depthOf));
+    const byParent = new Map();
+    for (const d of markers.filter((m) => depthOf(m) === depth)) {
+        const parent = d ? dirOf(d) : "";
+        byParent.set(parent, [...(byParent.get(parent) ?? []), d]);
+    }
+    // The parent with the most spaces; ties go to the first in path order
+    const [parent, group] = [...byParent].sort((a, b) => b[1].length - a[1].length || a[0].localeCompare(b[0]))[0];
+    const root = group.length > 1 ? parent : group[0];
+    const inRoot = paths.filter((p) => within(p, root)).map((p) => (root ? p.slice(root.length + 1) : p));
+    const spaces = gitbookSpaces(inRoot);
+    if (!spaces.length)
+        return undefined;
+    let pages = 0;
+    let gitbookDir = false;
+    for (const space of spaces) {
+        const spaceDir = space === "." ? "" : space;
+        const yaml = joinPath(spaceDir, ".gitbook.yaml");
+        if (inRoot.includes(yaml))
+            gitbookDir = true;
+        const docs = normalizePath(joinPath(spaceDir, configRoot(read?.(joinPath(root, yaml))))) ?? spaceDir;
+        for (const p of inRoot) {
+            if (!within(p, docs) || !gitbookVisible(p))
+                continue;
+            const rel = docs ? p.slice(docs.length + 1) : p;
+            if (rel.startsWith(".gitbook/"))
+                gitbookDir = true;
+            if (!/\.md$/i.test(rel) || rel.includes(".gitbook/includes/"))
+                continue;
+            const name = rel.slice(rel.lastIndexOf("/") + 1);
+            if (name === "SUMMARY.md" || name === "GLOSSARY.md")
+                continue;
+            pages++;
+        }
+    }
+    return {
+        format: "gitbook",
+        root,
+        // SUMMARY.md alone is also how HonKit and other book tools start; `.gitbook/` is GitBook's own
+        confidence: gitbookDir ? "high" : "low",
+        pages,
+        fidelity: "full",
+        ...(spaces.length > 1 ? { choices: { spaces } } : {}),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { type FormatName } from "./order.js";
+import type { Detection, ReadText } from "./types.js";
+export { FORMAT_ORDER, type FormatName } from "./order.js";
+export type { Detection, ReadText } from "./types.js";
+export { detectGitbook, gitbookSpaces, gitbookVisible } from "./gitbook.js";
+export { detectVitepress, vitepressConfigPath, vitepressPage, vitepressRoots, VITEPRESS_SKIP_DIRS } from "./vitepress.js";
+export { dirOf, isPlainPath, joinPath, normalizePath, within } from "./paths.js";
+/** The formats with a path detector, by name. */
+export declare const PATH_DETECTORS: Partial<Record<FormatName, (paths: string[], read?: ReadText) => Detection | undefined>>;
+/** The first format, in `FORMAT_ORDER`, whose path detector claims `paths`. */
+export declare function detect(paths: string[], read?: ReadText): Detection | undefined;

package/dist/index.js

@@ -0,0 +1,29 @@
+/**
+ * @dogsbay/detect — which documentation tool made a folder, from its paths. No Node, no
+ * dependencies: the playground runs it on a repo's tree before loading any importer, and the
+ * dogsbay CLI takes its format order from here (`FORMAT_ORDER`).
+ *
+ * Formats get a path detector here as their browser import lands (GitBook, VitePress); until then
+ * the CLI keeps detecting them on disk, in this same order.
+ */
+import { detectGitbook } from "./gitbook.js";
+import { detectVitepress } from "./vitepress.js";
+import { FORMAT_ORDER } from "./order.js";
+export { FORMAT_ORDER } from "./order.js";
+export { detectGitbook, gitbookSpaces, gitbookVisible } from "./gitbook.js";
+export { detectVitepress, vitepressConfigPath, vitepressPage, vitepressRoots, VITEPRESS_SKIP_DIRS } from "./vitepress.js";
+export { dirOf, isPlainPath, joinPath, normalizePath, within } from "./paths.js";
+/** The formats with a path detector, by name. */
+export const PATH_DETECTORS = {
+    gitbook: detectGitbook,
+    vitepress: (paths) => detectVitepress(paths),
+};
+/** The first format, in `FORMAT_ORDER`, whose path detector claims `paths`. */
+export function detect(paths, read) {
+    for (const name of FORMAT_ORDER) {
+        const found = PATH_DETECTORS[name]?.(paths, read);
+        if (found)
+            return found;
+    }
+    return undefined;
+}

package/dist/order.d.ts

@@ -0,0 +1,25 @@
+/**
+ * THE detection order of the import formats, by plugin name. The dogsbay CLI
+ * builds its plugin registry (`packages/cli/src/formats.ts`) in this order and
+ * refuses to start if the two name different formats; the playground runs the
+ * path detectors below in the same order. One list, so a browser import and
+ * `dogsbay convert` cannot disagree about what a folder is.
+ *
+ * ORDER IS DETECTION PRECEDENCE: the first importable format that claims a
+ * folder wins.
+ *
+ * Config-anchored detectors (mkdocs.yml, docusaurus.config.*, hugo.*, …) come
+ * first because they cannot false-positive. The two CATCH-ALL detectors go
+ * last-but-one and last-ish, and their relative order is load-bearing:
+ *
+ *   asciidoc   → a corpus whose `.adoc` files outnumber its `.md` files
+ *   dogsbay-md → any `.md` anywhere under the source
+ *
+ * asciidoc goes FIRST of the two: a real AsciiDoc corpus almost always carries
+ * a `README.md` (openshift-docs does), and markdown-first would claim it and
+ * import that one file instead of 20k pages. The inverse mistake is prevented
+ * inside asciidoc's own detector, which requires `.adoc` DOMINANCE rather than
+ * mere presence (`format-asciidoc/src/loaders/plain.ts`).
+ */
+export declare const FORMAT_ORDER: readonly ["mkdocs", "astro", "obsidian", "openknowledge", "mdx", "starlight", "docusaurus", "gitbook", "hugo", "vitepress", "rst", "myst", "asciidoc", "dogsbay-md", "gatsby", "openapi"];
+export type FormatName = (typeof FORMAT_ORDER)[number];

package/dist/order.js

@@ -0,0 +1,66 @@
+/**
+ * THE detection order of the import formats, by plugin name. The dogsbay CLI
+ * builds its plugin registry (`packages/cli/src/formats.ts`) in this order and
+ * refuses to start if the two name different formats; the playground runs the
+ * path detectors below in the same order. One list, so a browser import and
+ * `dogsbay convert` cannot disagree about what a folder is.
+ *
+ * ORDER IS DETECTION PRECEDENCE: the first importable format that claims a
+ * folder wins.
+ *
+ * Config-anchored detectors (mkdocs.yml, docusaurus.config.*, hugo.*, …) come
+ * first because they cannot false-positive. The two CATCH-ALL detectors go
+ * last-but-one and last-ish, and their relative order is load-bearing:
+ *
+ *   asciidoc   → a corpus whose `.adoc` files outnumber its `.md` files
+ *   dogsbay-md → any `.md` anywhere under the source
+ *
+ * asciidoc goes FIRST of the two: a real AsciiDoc corpus almost always carries
+ * a `README.md` (openshift-docs does), and markdown-first would claim it and
+ * import that one file instead of 20k pages. The inverse mistake is prevented
+ * inside asciidoc's own detector, which requires `.adoc` DOMINANCE rather than
+ * mere presence (`format-asciidoc/src/loaders/plain.ts`).
+ */
+export const FORMAT_ORDER = [
+    "mkdocs",
+    "astro",
+    "obsidian",
+    "openknowledge",
+    "mdx",
+    "starlight",
+    "docusaurus",
+    // gitbook BEFORE dogsbay-md: GitBook corpora are markdown, so the generic
+    // dogsbay-md detector would claim them first and skip the {% %} tag
+    // translation. gitbook's detector requires SUMMARY.md / .gitbook.yaml, so it
+    // can't false-positive on a real dogsbay-md site.
+    "gitbook",
+    // hugo BEFORE dogsbay-md: Hugo content is markdown, so the generic
+    // dogsbay-md detector would claim it first and skip every shortcode. Hugo's
+    // detector requires a hugo.*/config.* file AND a content directory, so it
+    // cannot false-positive on a plain markdown corpus.
+    "hugo",
+    // vitepress BEFORE dogsbay-md: VitePress content is markdown, so the generic
+    // dogsbay-md detector would claim it first and skip every `:::` container,
+    // code-group and `<<<` snippet. Its detector requires an actual
+    // `.vitepress/config.*`, so it cannot false-positive on a plain markdown,
+    // MkDocs or GitBook corpus.
+    "vitepress",
+    "rst",
+    // myst BEFORE dogsbay-md, AFTER gitbook/rst: MyST corpora are markdown, so
+    // the generic dogsbay-md detector would claim them first and skip the
+    // directive/role translation. myst's detector requires an explicit MyST
+    // config (myst.yml / _toc.yml) or MyST-specific syntax, so it can't
+    // false-positive on a plain dogsbay-md or GitBook site.
+    "myst",
+    // asciidoc BEFORE dogsbay-md: see the precedence note above.
+    "asciidoc",
+    "dogsbay-md",
+    "gatsby",
+    // openapi LAST. Its directory probe matches a top-level
+    // `openapi.{yaml,yml,json}` / `spec.*`, and plenty of docs corpora ship
+    // exactly that file alongside their pages (dub and ollama both do). In that
+    // case the DOCS format should win and the spec is imported deliberately with
+    // `--from openapi`; auto-detection only claims a bare spec file or a
+    // spec-only directory, where nothing else matches.
+    "openapi",
+];

package/dist/paths.d.ts

@@ -0,0 +1,20 @@
+/** Posix path helpers over corpus-relative paths ("" is the root). No Node. */
+/** The folder of a path: `a/b/c.md` → `a/b`, `c.md` → "". */
+export declare function dirOf(path: string): string;
+/** `a` + `b/c` → `a/b/c`; an empty side is dropped. */
+export declare function joinPath(a: string, b: string): string;
+/** Folder depth: "" → 0, `a` → 1, `a/b` → 2. */
+export declare function depthOf(dir: string): number;
+/** Is `path` the folder `dir` or inside it? */
+export declare function within(path: string, dir: string): boolean;
+/**
+ * Resolve `.` and `..` segments and drop a leading `./` or `/`. Undefined when the path leads
+ * above the root: a path from someone else's repo must not reach outside it.
+ */
+export declare function normalizePath(path: string): string | undefined;
+/**
+ * Is `path` a plain corpus path: posix, relative, no `.`/`..`/empty segment, no backslash,
+ * no control character? Anything else is left out of a corpus: a file named `b\..\..\x.md` is
+ * one segment on Linux and three levels up once a slug turns `\` into `/`.
+ */
+export declare function isPlainPath(path: string): boolean;

package/dist/paths.js

@@ -0,0 +1,45 @@
+/** Posix path helpers over corpus-relative paths ("" is the root). No Node. */
+/** The folder of a path: `a/b/c.md` → `a/b`, `c.md` → "". */
+export function dirOf(path) {
+    const i = path.lastIndexOf("/");
+    return i < 0 ? "" : path.slice(0, i);
+}
+/** `a` + `b/c` → `a/b/c`; an empty side is dropped. */
+export function joinPath(a, b) {
+    return a && b ? `${a}/${b}` : a || b;
+}
+/** Folder depth: "" → 0, `a` → 1, `a/b` → 2. */
+export function depthOf(dir) {
+    return dir ? dir.split("/").length : 0;
+}
+/** Is `path` the folder `dir` or inside it? */
+export function within(path, dir) {
+    return !dir || path === dir || path.startsWith(`${dir}/`);
+}
+/**
+ * Resolve `.` and `..` segments and drop a leading `./` or `/`. Undefined when the path leads
+ * above the root: a path from someone else's repo must not reach outside it.
+ */
+export function normalizePath(path) {
+    const out = [];
+    for (const seg of path.replace(/\\/g, "/").split("/")) {
+        if (seg === "" || seg === ".")
+            continue;
+        if (seg === "..") {
+            if (!out.length)
+                return undefined;
+            out.pop();
+        }
+        else
+            out.push(seg);
+    }
+    return out.join("/");
+}
+/**
+ * Is `path` a plain corpus path: posix, relative, no `.`/`..`/empty segment, no backslash,
+ * no control character? Anything else is left out of a corpus: a file named `b\..\..\x.md` is
+ * one segment on Linux and three levels up once a slug turns `\` into `/`.
+ */
+export function isPlainPath(path) {
+    return path !== "" && !/[\\\0-\x1f]/.test(path) && normalizePath(path) === path;
+}

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+import type { FormatName } from "./order.js";
+/** What a detector found: enough for a "convert it?" step, from paths alone. */
+export interface Detection {
+    format: FormatName;
+    /** The corpus folder, relative to the paths given ("" for their root). */
+    root: string;
+    /** "low" when the signal is shared with other tools (a bare SUMMARY.md). */
+    confidence: "high" | "low";
+    /** Pages the import would convert, as counted from paths. */
+    pages: number;
+    /** What the person may choose before converting. */
+    choices?: {
+        spaces?: string[];
+        versions?: string[];
+        locales?: string[];
+    };
+    /** "translate-only": the browser converts with less fidelity than the CLI (MyST without Sphinx). */
+    fidelity: "full" | "translate-only";
+}
+/** Reads one small text file (a config), by path relative to the paths' root; undefined if absent. */
+export type ReadText = (path: string) => string | undefined;

package/dist/types.js

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

package/dist/vitepress.d.ts

@@ -0,0 +1,18 @@
+/**
+ * VitePress from paths. `.vitepress/config.*` (or the split layout `.vitepress/config/index.*`)
+ * is the only unambiguous marker: requiring it is what keeps VitePress from claiming a
+ * plain-Markdown, MkDocs or GitBook corpus. The project root is the folder holding `.vitepress`.
+ * `@dogsbay/format-vitepress` finds its config through `vitepressConfigPath`, so detection and
+ * import cannot disagree.
+ */
+import type { Detection } from "./types.js";
+/** Folders a VitePress project keeps beside its pages, never pages themselves. */
+export declare const VITEPRESS_SKIP_DIRS: Set<string>;
+/** The config file of the project at `root`, as VitePress looks for it; undefined if none. */
+export declare function vitepressConfigPath(paths: Iterable<string>, root: string): string | undefined;
+/** Project roots among `paths`: the folders holding a `.vitepress` with a config, best first. */
+export declare function vitepressRoots(paths: string[]): string[];
+/** Is `path` (relative to a project root) a page VitePress would build, before its config is read? */
+export declare function vitepressPage(rel: string): boolean;
+/** Find a VitePress project among `paths` (a repo's whole tree, or one folder's listing). */
+export declare function detectVitepress(paths: string[]): Detection | undefined;

package/dist/vitepress.js

@@ -0,0 +1,60 @@
+import { depthOf, joinPath, within } from "./paths.js";
+const CONFIG_EXTS = [".ts", ".mts", ".mjs", ".js", ".cts", ".cjs"];
+/** Folders a VitePress project keeps beside its pages, never pages themselves. */
+export const VITEPRESS_SKIP_DIRS = new Set([".vitepress", "node_modules", "public", "dist", ".git", "cache", ".cache"]);
+/** Where a repo usually keeps its docs, preferred among folders at the same depth. */
+const PREFERRED = ["docs", "site", "website"];
+/** The config file of the project at `root`, as VitePress looks for it; undefined if none. */
+export function vitepressConfigPath(paths, root) {
+    const all = paths instanceof Set ? paths : new Set(paths);
+    const vp = joinPath(root, ".vitepress");
+    for (const ext of CONFIG_EXTS)
+        if (all.has(`${vp}/config${ext}`))
+            return `${vp}/config${ext}`;
+    for (const ext of CONFIG_EXTS)
+        if (all.has(`${vp}/config/index${ext}`))
+            return `${vp}/config/index${ext}`;
+    return undefined;
+}
+/** Project roots among `paths`: the folders holding a `.vitepress` with a config, best first. */
+export function vitepressRoots(paths) {
+    const all = new Set(paths);
+    const roots = new Set();
+    for (const p of paths) {
+        const m = /(^|\/)\.vitepress\/config(\/index)?\.[cm]?[jt]s$/.exec(p);
+        if (!m)
+            continue;
+        const root = p.slice(0, m.index);
+        // Not inside node_modules or another hidden folder (a vendored copy, a cache)
+        if (root.split("/").some((s) => s === "node_modules" || (s.startsWith(".") && s !== "")))
+            continue;
+        if (vitepressConfigPath(all, root))
+            roots.add(root);
+    }
+    const rank = (r) => {
+        const i = PREFERRED.indexOf(r.slice(r.lastIndexOf("/") + 1));
+        return i < 0 ? PREFERRED.length : i;
+    };
+    return [...roots].sort((a, b) => depthOf(a) - depthOf(b) || rank(a) - rank(b) || a.localeCompare(b));
+}
+/** Is `path` (relative to a project root) a page VitePress would build, before its config is read? */
+export function vitepressPage(rel) {
+    const segs = rel.split("/");
+    if (segs.slice(0, -1).some((s) => VITEPRESS_SKIP_DIRS.has(s) || s.startsWith(".")))
+        return false;
+    return /\.md$/i.test(segs[segs.length - 1]);
+}
+/** Find a VitePress project among `paths` (a repo's whole tree, or one folder's listing). */
+export function detectVitepress(paths) {
+    const [root] = vitepressRoots(paths);
+    if (root === undefined)
+        return undefined;
+    let pages = 0;
+    for (const p of paths) {
+        if (!within(p, root))
+            continue;
+        if (vitepressPage(root ? p.slice(root.length + 1) : p))
+            pages++;
+    }
+    return { format: "vitepress", root, confidence: "high", pages, fidelity: "full" };
+}

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "@dogsbay/detect",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0-beta.132",
+  "description": "Which documentation tool made this folder: the import formats' detection order (shared by the dogsbay CLI and the playground) and detectors that read paths only, with no Node and no dependencies",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "devDependencies": {
+    "esbuild": "^0.25.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.10"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dogsbay/dogsbay.git",
+    "directory": "packages/detect"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
 }