@dogsbay/format-obsidian 0.2.0-beta.156 → 0.2.0-beta.157

package/dist/capabilities.js

@@ -99,8 +99,8 @@ export const OBSIDIAN_CAPABILITIES = [
     {
         feature: "link-button",
         support: "partial",
-        rendersAs: "an ordinary Markdown link",
-        note: "Button styling and variant are lost; an unsafe href leaves the label as plain text.",
+        rendersAs: "`dogsbay-link-button` block (plugin renders the button with its variant)",
+        note: "A button is a block in the vault: one written inline in a sentence stands on its own line. An unsafe href leaves the label as plain text.",
     },
     { feature: "related", support: "full", rendersAs: "bold label + the link list" },
     {

package/dist/cli.js

@@ -1,7 +1,10 @@
-import { existsSync, mkdirSync, writeFileSync, readFileSync, cpSync, readdirSync, statSync } from "node:fs";
-import { join, dirname, resolve, relative } from "node:path";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, cpSync, statSync, copyFileSync } from "node:fs";
+import { join, dirname, resolve, relative, isAbsolute } from "node:path";
 import { fileURLToPath } from "node:url";
 import { exportObsidianVault } from "./project.js";
+import { mountCopies, assetsReferenced, assetCopies } from "@dogsbay/corpus";
+import { readFolder } from "@dogsbay/corpus/folder";
+const IMAGE_EXTS = new Set([".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp"]);
 import { OBSIDIAN_CAPABILITIES } from "./capabilities.js";
 const PLUGIN_ID = "dogsbay-docs";
 export const plugin = {
@@ -12,7 +15,7 @@ export const plugin = {
     detectSource: (path) => existsSync(join(path, ".obsidian")),
     importOptions: [],
     exportOptions: [
-        { flags: "--tabs <mode>", description: "Tab handling: dogsbay-tabs (default) or flatten", default: "dogsbay-tabs" },
+        { flags: "--assets <mode>", description: "Asset files: used (only what the notes refer to, default) or all (every file the importer mounted)", default: "used" },
         { flags: "--plugin <mode>", description: "Plugin setup: bundled (copy into vault), registry (list only), none", default: "bundled" },
         { flags: "--graph-groups <path>", description: "JSON file of graph-view colour groups: [{ \"query\": \"path:guides\", \"color\": \"#F2B36F\" }]. Replaces the default hub group. Ignored if the vault already has a graph.json" },
     ],
@@ -29,39 +32,72 @@ export const plugin = {
             writeFileSync(fullPath, content);
         }
         console.log(`Generated ${result.files.size} vault files`);
-        // Mounted asset dirs (a Starlight `src/assets`, a Docusaurus `static/`),
-        // copied to `_assets/` to match the `/_assets/…` refs importers rewrite
-        // image paths to. Without this the vault carried the reference and not the
-        // file — the note renders with a broken image and nothing reports it.
-        const mounts = opts.assetMounts;
-        for (const mount of mounts ?? []) {
+        // Mounted asset dirs (a Starlight `src/assets`, a Docusaurus `static/`), copied to where the
+        // `/_assets/…` refs importers rewrite image paths to point. Without this the vault carried the
+        // reference and not the file. Each mount is read through @dogsbay/corpus's contained reader
+        // (a symlink out of it, `node_modules` and `.git` are not copied — cpSync copied links to
+        // anywhere) and listed by the same rules as the Dogsbay MD export (`mountCopies`). By default
+        // only what a note refers to is copied: a whole Docusaurus `static/` brought other products'
+        // images and the site's `_headers`/`_redirects` (Tigera: 149 MB copied, 38 MB used).
+        const mounts = opts.assetMounts ?? [];
+        const assetsMode = opts.assets ?? "used";
+        if (assetsMode !== "used" && assetsMode !== "all")
+            throw new Error(`--assets must be used or all (got ${JSON.stringify(assetsMode)})`);
+        const copies = [];
+        for (const mount of mounts) {
             if (!existsSync(mount.dir))
                 continue;
-            // Folders the mount leaves out (VitePress: `public/`, a mount of its own)
-            const skipped = new Set((mount.skip ?? []).map((f) => join(mount.dir, f)));
-            // The mount carries the root its refs were rewritten to — `_assets`
-            // for an imported corpus, `images`/`assets` for hand-authored content.
-            // Hardcoding `_assets` here would copy the file somewhere the
-            // reference does not point, which is the broken-image-and-no-report
-            // failure this copy exists to prevent.
-            const root = mount.root ?? "_assets";
-            const dest = mount.into ? join(output, root, mount.into) : join(output, root);
-            mkdirSync(dest, { recursive: true });
-            // `mediaOnly` mounts are whole docs trees (the Docusaurus and VitePress
-            // importers mount their entire docs dir this way) — copying them wholesale
-            // buries hundreds of duplicate .md/.mdx notes under _assets/. Take only
-            // the media, matching format-dogsbay-md's copyMediaTree.
-            if (mount.mediaOnly) {
-                copyMediaTree(mount.dir, dest, skipped);
+            const folder = readFolder(mount.dir);
+            for (const c of mountCopies(folder.paths, [{ ...mount, dir: "" }]))
+                copies.push({ from: folder.absolute(c.from), to: c.to });
+        }
+        const roots = [...new Set(mounts.map((m) => m.root ?? "_assets"))];
+        const notes = [...result.files.values()].filter((v) => typeof v === "string");
+        // The same rules as Docusaurus's browser import (@dogsbay/corpus): references in every
+        // spelling, the last mount wins a path, an HTML file brings its folder, a note wins its path
+        const used = assetsMode === "all" ? undefined : assetsReferenced(notes, new Set(copies.map((c) => c.to)), roots);
+        const chosen = assetCopies(copies, new Set(result.files.keys()), used, roots.flatMap((r) => [`${r}/`, `${r}/pages/`]));
+        const written = new Set();
+        const outside = [];
+        let bytes = 0;
+        for (const { from, to } of chosen) {
+            // never outside the vault (a mount's `into`/`root` from an importer)
+            const dest = resolve(output, to);
+            const rel = relative(resolve(output), dest);
+            if (!rel || rel.startsWith("..") || isAbsolute(rel)) {
+                outside.push(to);
                 continue;
             }
-            cpSync(mount.dir, dest, { recursive: true, filter: (src) => !skipped.has(src) });
+            mkdirSync(dirname(dest), { recursive: true });
+            copyFileSync(from, dest);
+            written.add(to);
+            bytes += statSync(dest).size;
+        }
+        if (outside.length)
+            console.warn(`  skipped ${outside.length} asset path(s) outside the vault, e.g. ${JSON.stringify(outside[0])}`);
+        const seen = written;
+        if (copies.length) {
+            console.log(assetsMode === "all"
+                ? `Copied ${seen.size} asset file(s) (${(bytes / 1e6).toFixed(1)} MB)`
+                : `Copied ${seen.size} of ${copies.length} asset file(s) the notes refer to (${(bytes / 1e6).toFixed(1)} MB); --assets all copies every file`);
         }
-        // Co-located images from the source docs directory (the mkdocs shape,
-        // where media sits next to the markdown rather than in its own tree).
+        // Co-located images from the source docs directory (the mkdocs shape, where media sits next
+        // to the markdown rather than in its own tree): read contained too, at the same place.
         const sourceDir = opts.sourceDir;
-        if (sourceDir) {
-            copyImages(sourceDir, output);
+        if (sourceDir && existsSync(sourceDir)) {
+            const folder = readFolder(sourceDir);
+            let count = 0;
+            for (const path of folder.paths) {
+                const dot = path.lastIndexOf(".");
+                if (dot === -1 || !IMAGE_EXTS.has(path.slice(dot).toLowerCase()))
+                    continue;
+                const dest = join(output, path);
+                mkdirSync(dirname(dest), { recursive: true });
+                copyFileSync(folder.absolute(path), dest);
+                count++;
+            }
+            if (count > 0)
+                console.log(`Copied ${count} images into vault`);
         }
         // Set up plugin
         if (pluginMode === "bundled") {
@@ -201,34 +237,6 @@ function installGraphConfig(vaultDir, groupsPath) {
     }, null, 2) + "\n");
     console.log("Pre-configured graph view (.obsidian/graph.json)");
 }
-function copyImages(sourceDir, vaultDir) {
-    const imageExts = new Set([".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp"]);
-    let count = 0;
-    function walk(dir) {
-        for (const entry of readdirSync(dir)) {
-            const full = join(dir, entry);
-            if (statSync(full).isDirectory()) {
-                walk(full);
-            }
-            else {
-                const ext = entry.substring(entry.lastIndexOf(".")).toLowerCase();
-                if (imageExts.has(ext)) {
-                    const rel = relative(sourceDir, full);
-                    const dest = join(vaultDir, rel);
-                    mkdirSync(dirname(dest), { recursive: true });
-                    cpSync(full, dest);
-                    count++;
-                }
-            }
-        }
-    }
-    try {
-        walk(sourceDir);
-    }
-    catch { /* source may not exist */ }
-    if (count > 0)
-        console.log(`Copied ${count} images into vault`);
-}
 /**
  * Find the built plugin dist directory.
  * Searches relative to this package (sibling repo) and common locations.
@@ -251,31 +259,3 @@ function resolvePluginDist() {
     }
     return null;
 }
-/** Media extensions carried across for a `mediaOnly` mount — mirrors format-dogsbay-md. */
-const MEDIA_EXTS = new Set([
-    ".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif",
-    ".svg", ".ico", ".pdf", ".mp4", ".webm",
-]);
-/**
- * Copy only media files out of a mount, preserving its subtree shape.
- *
- * A `mediaOnly` mount is a whole docs directory (Docusaurus and VitePress both
- * mount theirs that way), so a recursive copy would bury every `.md`/`.mdx` in
- * the source under `_assets/` as duplicate notes.
- */
-function copyMediaTree(srcDir, destDir, skip) {
-    for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
-        const full = join(srcDir, entry.name);
-        if (skip?.has(full))
-            continue;
-        if (entry.isDirectory()) {
-            copyMediaTree(full, join(destDir, entry.name), skip);
-            continue;
-        }
-        const dot = entry.name.lastIndexOf(".");
-        if (dot === -1 || !MEDIA_EXTS.has(entry.name.slice(dot).toLowerCase()))
-            continue;
-        mkdirSync(destDir, { recursive: true });
-        cpSync(full, join(destDir, entry.name));
-    }
-}

package/dist/project.js

@@ -157,30 +157,6 @@ export function exportObsidianVault(pages, nav, options = {}) {
             }
         }
     }
-    // Minimal fence tracker for the two link passes below (format-obsidian
-    // may not depend on format-dogsbay-md at runtime — its tracker lives
-    // there). Open on a ```/~~~ run, close only on a run of the SAME char
-    // at >= the opener's length with nothing after it (a shorter run inside
-    // a longer fence is content).
-    const makeFenceTracker = () => {
-        let open = null;
-        return (line) => {
-            const m = line.match(/^\s*(`{3,}|~{3,})(.*)$/);
-            if (m) {
-                const [, run, rest] = m;
-                if (!open) {
-                    open = { char: run[0], len: run.length };
-                    return "fence";
-                }
-                if (run[0] === open.char && run.length >= open.len && rest.trim() === "") {
-                    open = null;
-                    return "fence";
-                }
-                return "code";
-            }
-            return open ? "code" : "prose";
-        };
-    };
     // Rescue links that spell the ORIGINAL repo path (#051). An xref can
     // name a DIFFERENT assembly of the same module than the one nav placed
     // (`edge_computing/…/update-completing-the-control-plane-only-update`
@@ -188,8 +164,10 @@ export function exportObsidianVault(pages, nav, options = {}) {
     // rewrite map above only knows nav-placed slugs. When the dangling
     // path's BASENAME names exactly one vault page, that page is the
     // target; ambiguous basenames stay dangling rather than guessing.
+    // Vault pages by BASENAME, for the two rescue passes below (links, then
+    // card/button hrefs).
+    const byBasename = new Map();
     {
-        const byBasename = new Map();
         for (const f of files.keys()) {
             if (!f.endsWith(".md") || f === sectionNotePath(f.slice(0, f.lastIndexOf("/"))))
                 continue;
@@ -380,6 +358,14 @@ export function exportObsidianVault(pages, nav, options = {}) {
                 if (files.has(candidate))
                     return `href: ${candidate}`;
             }
+            // Same rescue as a markdown link: a Starlight `<LinkButton
+            // href="/getting-started/">` names the page by its route while the
+            // vault filed it under its nav section (`start-here/`). A unique
+            // basename is the page; an ambiguous one stays as written.
+            const base = bare.slice(bare.lastIndexOf("/") + 1);
+            const candidates = byBasename.get(base);
+            if (candidates?.length === 1)
+                return `href: ${candidates[0]}.md`;
             return line;
         });
         if (updated !== content)
@@ -536,20 +522,37 @@ function sectionIndexTarget(child, folderPath, files, slugToVaultPath) {
 function navToYaml(items, indent = 0, slugToVaultPath) {
     const prefix = "  ".repeat(indent);
     const lines = [];
+    // A destination that is not a vault file (a URL, an in-page anchor) is written under `href:`,
+    // not `path:`: the plugin opens every `path:` with `vault.getFileByPath()`, so such a row was a
+    // dead click in the sidebar and a dead stop in prev/next. The plugin (dogsbay-obsidian
+    // feat/plugin-round-2) opens a URL in the browser, an anchor in the open note, and keeps both
+    // out of prev/next.
+    const target = (href) => {
+        if (isExternalHref(href))
+            return `href: ${yamlStr(href)}`;
+        // An anchor in any spelling (`#opts`, `/#opts`, `/docs#opts`) as the plugin reads it, `#opts`;
+        // one with no fragment (`/?tab=b`) has nowhere to go (review)
+        if (isAnchorOnly(href)) {
+            const fragment = href.includes("#") ? href.slice(href.indexOf("#") + 1) : "";
+            return fragment ? `href: ${yamlStr(`#${fragment}`)}` : undefined;
+        }
+        return `path: ${yamlStr(resolveNavPath(href, slugToVaultPath))}`;
+    };
     for (const item of items) {
         if (item.children && item.children.length > 0) {
             lines.push(`${prefix}- label: ${yamlStr(item.label)}`);
-            if (item.href) {
-                const path = resolveNavPath(item.href, slugToVaultPath);
-                lines.push(`${prefix}  path: ${yamlStr(path)}`);
-            }
+            const to = item.href ? target(item.href) : undefined;
+            if (to)
+                lines.push(`${prefix}  ${to}`);
             lines.push(`${prefix}  children:`);
             lines.push(navToYaml(item.children, indent + 2, slugToVaultPath));
         }
         else if (item.href) {
-            const path = resolveNavPath(item.href, slugToVaultPath);
+            const to = target(item.href);
+            if (!to)
+                continue;
             lines.push(`${prefix}- label: ${yamlStr(item.label)}`);
-            lines.push(`${prefix}  path: ${yamlStr(path)}`);
+            lines.push(`${prefix}  ${to}`);
         }
     }
     return lines.join("\n");
@@ -560,7 +563,7 @@ function resolveNavPath(href, slugToVaultPath) {
     // so a nav entry pointing at https://learn.mintlify.com became
     // "https://learn.mintlify.com.md" — a dangling path in every generated
     // _nav.yml that has an external destination.
-    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(href) || href.startsWith("mailto:"))
+    if (isExternalHref(href))
         return href;
     // An in-page anchor is not a vault path either — appending `.md` produced a
     // `#options.md` nav row pointing at a file that is never written, and if the
@@ -699,3 +702,30 @@ function yamlStr(s) {
     }
     return s;
 }
+function isExternalHref(href) {
+    return /^[a-z][a-z0-9+.-]*:\/\//i.test(href) || /^mailto:/i.test(href);
+}
+// Minimal fence tracker for the two link passes below (format-obsidian
+// may not depend on format-dogsbay-md at runtime — its tracker lives
+// there). Open on a ```/~~~ run, close only on a run of the SAME char
+// at >= the opener's length with nothing after it (a shorter run inside
+// a longer fence is content).
+function makeFenceTracker() {
+    let open = null;
+    return (line) => {
+        const m = line.match(/^\s*(`{3,}|~{3,})(.*)$/);
+        if (m) {
+            const [, run, rest] = m;
+            if (!open) {
+                open = { char: run[0], len: run.length };
+                return "fence";
+            }
+            if (run[0] === open.char && run.length >= open.len && rest.trim() === "") {
+                open = null;
+                return "fence";
+            }
+            return "code";
+        }
+        return open ? "code" : "prose";
+    };
+}

package/dist/serialize.js

@@ -165,15 +165,23 @@ function nodeToObsidian(node) {
             return childrenToObsidian(node);
         case "annotation-list":
             return childrenToObsidian(node);
-        case "link-button": {
-            const raw = node.props?.href ?? "";
-            const href = raw && isSafeHref(raw) ? obsidianHref(raw) : "";
-            const text = childrenToObsidian(node) || esc(href);
-            return href ? `[${text}](${markdownDestination(href)})` : text;
-        }
+        case "link-button":
+            return linkButtonToObsidian(node);
         case "hr":
+        // The MDX importers (Starlight, Docusaurus) emit `thematic-break` for a
+        // `---`; format-dogsbay-md emits `hr`. With no case, the default path
+        // returned "" for the MDX shape and every rule vanished from the vault.
+        case "thematic-break":
             return "---";
         case "html":
+            // A lone closing tag of a COMPONENT (`</Preview>`, `</FileTree>`): the
+            // MDX importer consumed the opener as JSX, but a closer that follows a
+            // blank line is an html_block to markdown-it and arrives here as raw
+            // HTML. Obsidian shows it as literal text — hundreds of lines on
+            // Starlight's docs. An HTML element's closer (`</div>`) is kept: it may
+            // pair with an opener passed through earlier.
+            if (isOrphanComponentCloser(node.html ?? ""))
+                return "";
             return vaultifyHtmlAssets(node.html ?? "");
         case "html-container":
             // Parsed from raw HTML (a one-line `<details>` body), the content is in
@@ -181,15 +189,10 @@ function nodeToObsidian(node) {
             if (!node.children?.length && node.html)
                 return vaultifyHtmlAssets(node.html);
             return childrenToObsidian(node);
-        case "link-card": {
-            // The parser folds a one-paragraph body into `props.description`, so a
-            // link card often has no children; with no case it emitted nothing
-            const description = node.props?.description?.trim();
-            const body = node.children?.length
-                ? node.children
-                : description ? [{ type: "paragraph", inline: [{ type: "text", text: description }] }] : [];
-            return cardToObsidian({ ...node, type: "card", children: body });
-        }
+        case "link-card":
+            // Same shape as a card with its one-paragraph body in
+            // `props.description`; `cardToObsidian` reads that itself.
+            return cardToObsidian(node);
         case "accordion":
             return (node.children ?? []).map(nodeToObsidian).filter(Boolean).join("\n\n");
         case "accordion-item":
@@ -720,7 +723,8 @@ function stepsToObsidian(node) {
             "";
         const content = childrenToObsidian(child);
         if (title) {
-            return content ? `step: ${title}\n---\n${content}` : `step: ${title}\n---`;
+            const line = stepTitleLine(title);
+            return content ? `step: ${line}\n---\n${content}` : `step: ${line}\n---`;
         }
         // No title — just content (Starlight steps are titleless list items)
         return content ? `step:\n---\n${content}` : `step:\n---`;
@@ -789,7 +793,23 @@ function cardToObsidian(node) {
     const rawHref = node.props?.href;
     const href = rawHref && isSafeHref(rawHref) ? oneLine(rawHref) : undefined;
     const icon = node.props?.icon;
-    const content = childrenToObsidian(node);
+    // The card is a fenced block, so its fence must differ from any fence its
+    // BODY writes — the same alternation tabs, steps and deflists use. A fixed
+    // triple-backtick fence (the old behaviour) was closed early by a code block
+    // in the body, and a card inside a backtick-fenced tabs/steps block closed
+    // that block instead; Starlight CardGrid pages hit both.
+    const fence = codeBlockNestingDepth % 2 === 0 ? "~~~" : "```";
+    codeBlockNestingDepth++;
+    let content = childrenToObsidian(node);
+    codeBlockNestingDepth--;
+    // The parser folds a one-paragraph body into `props.description` (a
+    // link-card, or Starlight's `<LinkCard description>` which maps to `card`),
+    // so the node has no children — read it, or the description is lost.
+    if (!content) {
+        const description = node.props?.description?.trim();
+        if (description)
+            content = esc(description);
+    }
     const header = [];
     if (title)
         header.push(`title: ${title}`);
@@ -821,9 +841,39 @@ function cardToObsidian(node) {
         return "";
     const meta = header.join("\n");
     if (content) {
-        return `\`\`\`dogsbay-card\n${meta}\n---\n${content}\n\`\`\``;
+        return `${fence}dogsbay-card\n${meta}\n---\n${content}\n${fence}`;
     }
-    return `\`\`\`dogsbay-card\n${meta}\n\`\`\``;
+    return `${fence}dogsbay-card\n${meta}\n${fence}`;
+}
+/**
+ * A `link-button` as the `dogsbay-link-button` block the dogsbay-docs plugin
+ * renders (`href:` / `variant:` / `---` / label). It used to be written as an
+ * ordinary Markdown link, which lost the call-to-action styling the plugin
+ * already had a processor for. With no safe href the label stays as text.
+ */
+function linkButtonToObsidian(node) {
+    const raw = node.props?.href ?? "";
+    const href = raw && isSafeHref(raw) ? obsidianHref(raw) : "";
+    const text = childrenToObsidian(node) || esc(href);
+    if (!href)
+        return text;
+    const fence = codeBlockNestingDepth % 2 === 0 ? "~~~" : "```";
+    const variant = node.props?.variant;
+    // Resolved by the plugin the way a card's is (exact vault path), so an
+    // internal target carries `.md`; project.ts then points it at the file
+    // that exists.
+    const header = [`href: ${cardHref(oneLine(href))}`];
+    if (variant)
+        header.push(`variant: ${oneLine(variant)}`);
+    return `${fence}dogsbay-link-button\n${header.join("\n")}\n---\n${oneLine(text)}\n${fence}`;
+}
+/**
+ * Raw HTML that is nothing but closing tags of PascalCase names — a JSX
+ * component's closer the MDX importer could not pair with its opener.
+ */
+function isOrphanComponentCloser(html) {
+    const t = html.trim();
+    return t.length > 0 && /^(<\/[A-Z][A-Za-z0-9]*\s*>\s*)+$/.test(t);
 }
 function cardsToObsidian(node) {
     // Flatten cards/grid to a simple unordered list
@@ -1161,3 +1211,15 @@ function oneLine(s) {
 function chooseFence(content) {
     return pickCodeFence(content);
 }
+/**
+ * A step title on its `step:` line, which the plugin renders as Markdown: one line, and a start
+ * that would make it a block (`1. Install` a list, `# x` a heading, `> x` a quote, `---` a rule)
+ * escaped, so it stays the title's text (review, 2026-11-02).
+ */
+function stepTitleLine(title) {
+    return title
+        .replace(/\s*\n\s*/g, " ")
+        .replace(/^(\d{1,9})([.)])(?=\s|$)/, "$1\\$2")
+        .replace(/^([>+]|[-*](?=\s)|#{1,6}(?=\s|$))/, "\\$1")
+        .replace(/^([-*_])(?=(?:\s*\1){2,}\s*$)/, "\\$1");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dogsbay/format-obsidian",
-  "version": "0.2.0-beta.156",
+  "version": "0.2.0-beta.157",
   "description": "Obsidian format plugin for Dogsbay — import/export Obsidian vaults via TreeNode[]",
   "type": "module",
   "main": "dist/index.js",
@@ -23,13 +23,14 @@
     "@types/node": "^25.9.5",
     "typescript": "^5.9.3",
     "vitest": "^4.1.10",
-    "@dogsbay/format-dogsbay-md": "0.2.0-beta.156",
-    "@dogsbay/format-openapi": "0.2.0-beta.156"
+    "@dogsbay/format-openapi": "0.2.0-beta.157",
+    "@dogsbay/format-dogsbay-md": "0.2.0-beta.157"
   },
   "license": "MIT",
   "dependencies": {
-    "@dogsbay/serialize-core": "0.2.0-beta.156",
-    "@dogsbay/types": "0.2.0-beta.156"
+    "@dogsbay/corpus": "0.2.0-beta.157",
+    "@dogsbay/serialize-core": "0.2.0-beta.157",
+    "@dogsbay/types": "0.2.0-beta.157"
   },
   "repository": {
     "type": "git",