@interactive-inc/docs-client 0.0.5 → 0.0.7

package/build/index.js

@@ -1,39 +1,4616 @@
-export { DocClient } from "./doc-client";
-export { DocDirectoryReference } from "./doc-directory-reference";
-export { DocFileIndexReference } from "./doc-file-index-reference";
-export { DocFileMdReference } from "./doc-file-md-reference";
-export { DocFileRelationReference } from "./doc-file-relation-reference";
-export { DocFileSystem } from "./doc-file-system";
-export { DocFileTreeSystem as FileTreeSystem } from "./doc-file-tree-system";
-export { DocFileUnknownReference } from "./doc-file-unknown-reference";
-export { DocMarkdownSystem } from "./doc-markdown-system";
-export { DocPathSystem } from "./doc-path-system";
-export { DocFileIndexEntity } from "./entities/doc-file-index-entity";
-export { DocFileMdEntity } from "./entities/doc-file-md-entity";
-export { DocFileUnknownEntity } from "./entities/doc-file-unknown-entity";
-export * from "./models";
-export { DocContentMdValue } from "./values/doc-content-md-value";
-export { DocDirectoryPathValue } from "./values/doc-directory-path-value";
-export { DocFileContentIndexValue } from "./values/doc-file-content-index-value";
-export { DocFileContentMdValue } from "./values/doc-file-content-md-value";
-export { DocFilePathValue } from "./values/doc-file-path-value";
-export { DocFrontMatterIndexValue } from "./values/doc-front-matter-index-value";
-export { DocFrontMatterMdValue } from "./values/doc-front-matter-md-value";
-export { DocRelationFileValue } from "./values/doc-relation-file-value";
-export { DocRelationValue } from "./values/doc-relation-value";
-export { DocSchemaFieldBooleanMultipleValue } from "./values/doc-schema-field-boolean-multiple-value";
-export { DocSchemaFieldBooleanSingleValue } from "./values/doc-schema-field-boolean-single-value";
-export { DocSchemaFieldFactory } from "./values/doc-schema-field-factory";
-export { DocSchemaFieldNumberMultipleValue } from "./values/doc-schema-field-number-multiple-value";
-export { DocSchemaFieldNumberSingleValue } from "./values/doc-schema-field-number-single-value";
-export { DocSchemaFieldRelationMultipleValue } from "./values/doc-schema-field-relation-multiple-value";
-export { DocSchemaFieldRelationSingleValue } from "./values/doc-schema-field-relation-single-value";
-export { DocSchemaFieldSelectNumberMultipleValue } from "./values/doc-schema-field-select-number-multiple-value";
-export { DocSchemaFieldSelectNumberSingleValue } from "./values/doc-schema-field-select-number-single-value";
-export { DocSchemaFieldSelectTextMultipleValue } from "./values/doc-schema-field-select-text-multiple-value";
-export { DocSchemaFieldSelectTextSingleValue } from "./values/doc-schema-field-select-text-single-value";
-export { DocSchemaFieldTextMultipleValue } from "./values/doc-schema-field-text-multiple-value";
-export { DocSchemaFieldTextSingleValue } from "./values/doc-schema-field-text-single-value";
-export { DocSchemaValue } from "./values/doc-schema-value";
-export { DocTreeDirectoryNodeValue } from "./values/doc-tree-directory-node-value";
-export { DocTreeFileNodeValue } from "./values/doc-tree-file-node-value";
+// lib/models.ts
+import { z } from "zod/v4";
+var zDocFilePath = z.object({
+  name: z.string(),
+  path: z.string(),
+  fullPath: z.string(),
+  nameWithExtension: z.string()
+});
+var zDocSchemaFieldTypeText = z.literal("text");
+var zDocSchemaFieldTypeNumber = z.literal("number");
+var zDocSchemaFieldTypeBoolean = z.literal("boolean");
+var zDocSchemaFieldTypeMultiText = z.literal("multi-text");
+var zDocSchemaFieldTypeMultiNumber = z.literal("multi-number");
+var zDocSchemaFieldTypeMultiBoolean = z.literal("multi-boolean");
+var zDocSchemaFieldTypeRelation = z.literal("relation");
+var zDocSchemaFieldTypeMultiRelation = z.literal("multi-relation");
+var zDocSchemaFieldTypeSelectText = z.literal("select-text");
+var zDocSchemaFieldTypeSelectNumber = z.literal("select-number");
+var zDocSchemaFieldTypeMultiSelectText = z.literal("multi-select-text");
+var zDocSchemaFieldTypeMultiSelectNumber = z.literal("multi-select-number");
+var zDocSchemaFieldType = z.union([
+  zDocSchemaFieldTypeText,
+  zDocSchemaFieldTypeNumber,
+  zDocSchemaFieldTypeBoolean,
+  zDocSchemaFieldTypeMultiText,
+  zDocSchemaFieldTypeMultiNumber,
+  zDocSchemaFieldTypeMultiBoolean,
+  zDocSchemaFieldTypeRelation,
+  zDocSchemaFieldTypeMultiRelation,
+  zDocSchemaFieldTypeSelectText,
+  zDocSchemaFieldTypeSelectNumber,
+  zDocSchemaFieldTypeMultiSelectText,
+  zDocSchemaFieldTypeMultiSelectNumber
+]);
+var zDocSchemaFieldText = z.object({
+  type: zDocSchemaFieldTypeText,
+  required: z.boolean(),
+  title: z.string().nullable(),
+  description: z.string().nullable(),
+  default: z.string().nullable()
+});
+var zDocSchemaFieldNumber = z.object({
+  type: zDocSchemaFieldTypeNumber,
+  required: z.boolean(),
+  title: z.string().nullable(),
+  description: z.string().nullable(),
+  default: z.number().nullable()
+});
+var zDocSchemaFieldBoolean = z.object({
+  type: zDocSchemaFieldTypeBoolean,
+  required: z.boolean(),
+  title: z.string().nullable(),
+  description: z.string().nullable(),
+  default: z.boolean().nullable()
+});
+var zDocSchemaFieldMultiText = z.object({
+  type: zDocSchemaFieldTypeMultiText,
+  required: z.boolean(),
+  title: z.string().nullable(),
+  description: z.string().nullable(),
+  default: z.array(z.string()).nullable()
+});
+var zDocSchemaFieldMultiNumber = z.object({
+  type: zDocSchemaFieldTypeMultiNumber,
+  required: z.boolean(),
+  title: z.string().nullable(),
+  description: z.string().nullable(),
+  default: z.array(z.number()).nullable()
+});
+var zDocSchemaFieldMultiBoolean = z.object({
+  type: zDocSchemaFieldTypeMultiBoolean,
+  required: z.boolean(),
+  title: z.string().nullable(),
+  description: z.string().nullable(),
+  default: z.array(z.boolean()).nullable()
+});
+var zDocSchemaFieldRelation = z.object({
+  type: zDocSchemaFieldTypeRelation,
+  required: z.boolean(),
+  title: z.string().nullable(),
+  description: z.string().nullable(),
+  path: z.string().min(1),
+  default: z.string().nullable()
+});
+var zDocSchemaFieldMultiRelation = z.object({
+  type: zDocSchemaFieldTypeMultiRelation,
+  required: z.boolean(),
+  title: z.string().nullable(),
+  description: z.string().nullable(),
+  path: z.string().min(1),
+  default: z.array(z.string()).nullable()
+});
+var zDocSchemaFieldSelectText = z.object({
+  type: zDocSchemaFieldTypeSelectText,
+  required: z.boolean(),
+  title: z.string().nullable(),
+  description: z.string().nullable(),
+  options: z.array(z.string()),
+  default: z.string().nullable()
+});
+var zDocSchemaFieldSelectNumber = z.object({
+  type: zDocSchemaFieldTypeSelectNumber,
+  required: z.boolean(),
+  title: z.string().nullable(),
+  description: z.string().nullable(),
+  options: z.array(z.number()),
+  default: z.number().nullable()
+});
+var zDocSchemaFieldMultiSelectText = z.object({
+  type: zDocSchemaFieldTypeMultiSelectText,
+  required: z.boolean(),
+  title: z.string().nullable(),
+  description: z.string().nullable(),
+  options: z.array(z.string()),
+  default: z.array(z.string()).nullable()
+});
+var zDocSchemaFieldMultiSelectNumber = z.object({
+  type: zDocSchemaFieldTypeMultiSelectNumber,
+  required: z.boolean(),
+  title: z.string().nullable(),
+  description: z.string().nullable(),
+  options: z.array(z.number()),
+  default: z.array(z.number()).nullable()
+});
+var zDocSchemaField = z.union([
+  zDocSchemaFieldText,
+  zDocSchemaFieldNumber,
+  zDocSchemaFieldBoolean,
+  zDocSchemaFieldMultiText,
+  zDocSchemaFieldMultiNumber,
+  zDocSchemaFieldMultiBoolean,
+  zDocSchemaFieldRelation,
+  zDocSchemaFieldMultiRelation,
+  zDocSchemaFieldSelectText,
+  zDocSchemaFieldSelectNumber,
+  zDocSchemaFieldMultiSelectText,
+  zDocSchemaFieldMultiSelectNumber
+]);
+var zDocFileMdFrontMatter = z.record(
+  z.string(),
+  z.union([
+    z.string(),
+    z.boolean(),
+    z.number(),
+    z.array(z.string()),
+    z.array(z.number()),
+    z.array(z.boolean()),
+    z.record(z.string(), z.unknown()),
+    z.null()
+  ])
+);
+var zDocSchema = z.record(z.string(), zDocSchemaField);
+var zDocFileIndexFrontMatter = z.object({
+  type: z.literal("index-frontmatter"),
+  icon: z.string(),
+  schema: zDocSchema
+});
+var zDocRelationField = z.object({
+  fieldName: z.string(),
+  filePath: z.string(),
+  isArray: z.boolean()
+});
+var zDocRelationFile = z.object({
+  name: z.string(),
+  label: z.string().nullable(),
+  value: z.string().nullable(),
+  path: z.string().nullable()
+});
+var zDocRelation = z.object({
+  path: z.string(),
+  files: z.array(zDocRelationFile)
+});
+var zDocFileContentMd = z.object({
+  type: z.literal("markdown-content"),
+  body: z.string(),
+  title: z.string(),
+  description: z.string(),
+  frontMatter: zDocFileMdFrontMatter
+});
+var zDocFileContentIndex = z.object({
+  type: z.literal("markdown-index"),
+  body: z.string(),
+  title: z.string(),
+  description: z.string(),
+  frontMatter: zDocFileIndexFrontMatter
+});
+var zDocFileIndex = z.object({
+  type: z.literal("index"),
+  path: zDocFilePath,
+  content: zDocFileContentIndex,
+  isArchived: z.boolean()
+});
+var zDocFileUnknown = z.object({
+  type: z.literal("unknown"),
+  path: zDocFilePath,
+  content: z.string(),
+  extension: z.string(),
+  isArchived: z.boolean()
+});
+var zDocFileMd = z.object({
+  type: z.literal("markdown"),
+  path: zDocFilePath,
+  content: zDocFileContentMd,
+  isArchived: z.boolean()
+});
+var zDocFile = z.union([zDocFileIndex, zDocFileMd, zDocFileUnknown]);
+var zDocTreeFileNode = z.object({
+  type: z.literal("file"),
+  name: z.string(),
+  path: z.string(),
+  icon: z.string(),
+  title: z.string()
+});
+var zDocTreeDirectoryNode = z.lazy(() => {
+  return z.object({
+    type: z.literal("directory"),
+    name: z.string(),
+    path: z.string(),
+    icon: z.string(),
+    title: z.string(),
+    children: z.array(z.union([zDocTreeFileNode, zDocTreeDirectoryNode]))
+  });
+});
+var zDocTreeNode = z.union([zDocTreeFileNode, zDocTreeDirectoryNode]);
+
+// lib/doc-markdown-system.ts
+var DocMarkdownSystem = class {
+  frontMatterSeparator = "---";
+  constructor() {
+    Object.freeze(this);
+  }
+  /**
+   * FrontMatterの区切り線を検出
+   */
+  detectFrontMatterSeparator(text) {
+    const firstLine = text.split("\n")[0];
+    if (firstLine?.match(/^-{3,}$/)) {
+      return firstLine;
+    }
+    return this.frontMatterSeparator;
+  }
+  /**
+   * FrontMatterを抽出
+   */
+  extractFrontMatter(text) {
+    const separator = this.detectFrontMatterSeparator(text);
+    if (!text.startsWith(separator)) {
+      return null;
+    }
+    const endIndex = text.indexOf(`
+${separator}`, separator.length);
+    if (endIndex === -1) {
+      return null;
+    }
+    return text.slice(0, endIndex + separator.length + 1);
+  }
+  /**
+   * FrontMatterを除去したbody（titleとdescriptionを含む）
+   */
+  extractBody(text) {
+    const frontMatter = this.extractFrontMatter(text);
+    if (!frontMatter) {
+      return text;
+    }
+    return text.slice(frontMatter.length).trim();
+  }
+  /**
+   * タイトル
+   */
+  extractTitle(text) {
+    const body = this.extractBody(text);
+    const titleMatch = body.match(/^#\s+(.+)$/m);
+    return titleMatch?.[1] ?? null;
+  }
+  /**
+   * 説明（タイトルの後の最初の段落）
+   */
+  extractDescription(text) {
+    const title = this.extractTitle(text);
+    if (!title) {
+      return null;
+    }
+    const body = this.extractBody(text);
+    const lines = body.split("\n");
+    const titleIndex = lines.findIndex((line) => line.match(/^#\s+/));
+    if (titleIndex === -1) {
+      return null;
+    }
+    const descIndex = this.skipEmptyLines(lines, titleIndex + 1);
+    if (descIndex < lines.length && !lines[descIndex]?.startsWith("#")) {
+      return lines[descIndex] ?? null;
+    }
+    return null;
+  }
+  /**
+   * body内のタイトルを更新
+   */
+  updateTitle(text, newTitle) {
+    const body = this.extractBody(text);
+    const lines = body.split("\n");
+    const titleIndex = lines.findIndex((line) => line.match(/^#\s+/));
+    if (titleIndex !== -1) {
+      lines[titleIndex] = `# ${newTitle}`;
+    } else {
+      lines.unshift(`# ${newTitle}`, "");
+    }
+    const updatedBody = lines.join("\n");
+    const frontMatter = this.extractFrontMatter(text);
+    return frontMatter ? `${frontMatter}
+${updatedBody}` : updatedBody;
+  }
+  /**
+   * body内の説明を更新
+   */
+  updateDescription(text, newDescription, defaultTitle) {
+    const body = this.extractBody(text);
+    const lines = body.split("\n");
+    const titleIndex = lines.findIndex((line) => line.match(/^#\s+/));
+    let updatedBody;
+    if (titleIndex === -1) {
+      updatedBody = `# ${defaultTitle}
+
+${newDescription}
+
+${body}`.trim();
+    } else {
+      const descIndex = this.skipEmptyLines(lines, titleIndex + 1);
+      if (descIndex < lines.length && lines[descIndex] && !lines[descIndex].startsWith("#")) {
+        lines[descIndex] = newDescription;
+      } else {
+        lines.splice(titleIndex + 1, 0, "", newDescription);
+      }
+      updatedBody = lines.join("\n");
+    }
+    const frontMatter = this.extractFrontMatter(text);
+    return frontMatter ? `${frontMatter}
+${updatedBody}` : updatedBody;
+  }
+  /**
+   * 空行をスキップ
+   */
+  skipEmptyLines(lines, startIndex) {
+    let index = startIndex;
+    while (index < lines.length) {
+      const line = lines[index];
+      if (line === void 0 || line.trim() !== "") {
+        break;
+      }
+      index++;
+    }
+    return index;
+  }
+  /**
+   * Markdownテキストを生成（タイトル + 説明 + body）
+   */
+  static from(title, description, body) {
+    const parts = [];
+    if (title) {
+      parts.push(`# ${title}`);
+    }
+    if (description) {
+      if (title) parts.push("");
+      parts.push(description);
+    }
+    if (body) {
+      if (title || description) parts.push("");
+      parts.push(body);
+    }
+    return parts.join("\n");
+  }
+};
+
+// lib/values/doc-front-matter-md-value.ts
+import { stringify as stringify2 } from "yaml";
+
+// lib/values/doc-content-md-front-matter-value.ts
+import { parse, stringify } from "yaml";
+var DocContentMdFrontMatterValue = class _DocContentMdFrontMatterValue {
+  data;
+  yamlText;
+  constructor(data, yamlText = "") {
+    this.data = data;
+    this.yamlText = yamlText;
+  }
+  /**
+   * YAMLテキストからフロントマターインスタンスを作成
+   */
+  static fromYamlText(yamlText) {
+    if (!yamlText || typeof yamlText !== "string" || !yamlText.trim()) {
+      return new _DocContentMdFrontMatterValue({}, "");
+    }
+    const parsed = parse(yamlText) || {};
+    return new _DocContentMdFrontMatterValue(parsed, yamlText);
+  }
+  /**
+   * Markdownテキストからフロントマターインスタンスを作成
+   */
+  static fromMarkdown(markdownText) {
+    if (!markdownText || !markdownText.startsWith("---")) {
+      return _DocContentMdFrontMatterValue.empty();
+    }
+    const startIndex = markdownText.indexOf("---");
+    const endIndex = markdownText.indexOf("---", startIndex + 3);
+    if (endIndex === -1) {
+      return _DocContentMdFrontMatterValue.empty();
+    }
+    const yamlText = markdownText.slice(startIndex + 3, endIndex).trim();
+    return _DocContentMdFrontMatterValue.fromYamlText(yamlText);
+  }
+  /**
+   * 空のフロントマターインスタンスを作成
+   */
+  static empty() {
+    return new _DocContentMdFrontMatterValue(null, "");
+  }
+  /**
+   * フロントマターデータからインスタンスを作成
+   */
+  static fromFrontMatter(data) {
+    const instance = new _DocContentMdFrontMatterValue(data, "");
+    const yamlText = instance.frontMatterText();
+    return new _DocContentMdFrontMatterValue(data, yamlText);
+  }
+  /**
+   * フロントマターをYAMLテキストに変換
+   */
+  frontMatterText() {
+    if (this.data === null || Object.keys(this.data).length === 0) return "";
+    return stringify(this.data).trim();
+  }
+  /**
+   * フロントマターを更新した新しいインスタンスを作成
+   */
+  update(draft) {
+    const updatedData = { ...this.data || {} };
+    for (const [key, value] of Object.entries(draft)) {
+      updatedData[key] = value;
+    }
+    return _DocContentMdFrontMatterValue.fromFrontMatter(updatedData);
+  }
+  /**
+   * フロントマターが空かどうか
+   */
+  isEmpty() {
+    return this.data === null || Object.keys(this.data).length === 0;
+  }
+  /**
+   * 指定したキーの値を取得
+   */
+  get(key) {
+    return this.data?.[key];
+  }
+  /**
+   * 指定したキーが存在するか
+   */
+  has(key) {
+    return this.data !== null && key in this.data;
+  }
+  /**
+   * フロントマターのキー一覧を取得
+   */
+  keys() {
+    return this.data ? Object.keys(this.data) : [];
+  }
+};
+
+// lib/values/doc-content-md-value.ts
+var DocContentMdValue = class _DocContentMdValue {
+  constructor(text) {
+    this.text = text;
+  }
+  /**
+   * Front Matter
+   */
+  get frontMatter() {
+    return DocContentMdFrontMatterValue.fromMarkdown(this.text);
+  }
+  /**
+   * body
+   */
+  get content() {
+    if (!this.text || typeof this.text !== "string") {
+      return this.text || "";
+    }
+    if (!this.text.startsWith("---")) {
+      return this.text;
+    }
+    const startIndex = this.text.indexOf("---");
+    const endIndex = this.text.indexOf("---", startIndex + 3);
+    if (endIndex === -1) {
+      return this.text;
+    }
+    let content = this.text.slice(endIndex + 3);
+    if (this.text.slice(endIndex + 3).startsWith("\n\n")) {
+      content = `
+${this.text.slice(endIndex + 4).trim()}`;
+    } else {
+      content = this.text.slice(endIndex + 3).trim();
+    }
+    return content.trim();
+  }
+  /**
+   * title
+   */
+  get title() {
+    const content = this.content;
+    if (!content || typeof content !== "string") {
+      return "";
+    }
+    const titleMatch = content.match(/^#\s+(.*?)$/m);
+    if (!titleMatch || !titleMatch[1]) {
+      return "";
+    }
+    return titleMatch[1].trim();
+  }
+  /**
+   * H1の次の段落、またはH1がない場合は最初の段落をdescriptionとして取得する
+   */
+  get description() {
+    const content = this.content;
+    const h1Match = content.match(/^#\s+(.+)$/m);
+    let searchContent;
+    if (h1Match) {
+      const h1EndIndex = (h1Match.index ?? 0) + h1Match[0].length;
+      searchContent = content.substring(h1EndIndex);
+    } else {
+      searchContent = content;
+    }
+    const paragraphMatch = searchContent.match(
+      /^\s*\n*([^#\n*-][^\n]*(?:\n(?![#\s*-])[^\n]*)*)/m
+    );
+    return paragraphMatch ? paragraphMatch[1]?.trim() ?? null : null;
+  }
+  /**
+   * 新しいフロントマターとコンテンツでMarkdownインスタンスを作成
+   */
+  static fromProps(props) {
+    const contentOpenMarkdown = new _DocContentMdValue(props.content);
+    const existingContent = contentOpenMarkdown.content;
+    const frontMatterInstance = DocContentMdFrontMatterValue.fromFrontMatter(
+      props.frontMatter
+    );
+    const frontMatterText = frontMatterInstance.frontMatterText();
+    let markdownText;
+    if (frontMatterText) {
+      markdownText = `---
+${frontMatterText}
+---
+
+${existingContent}`.trim();
+    } else {
+      markdownText = existingContent;
+    }
+    return new _DocContentMdValue(markdownText);
+  }
+  /**
+   * 現在のフロントマターをYAMLテキストに変換する
+   */
+  frontMatterToText() {
+    return this.frontMatter.frontMatterText();
+  }
+  /**
+   * 現在のフロントマターを更新して新しいMarkdownテキストを生成
+   */
+  updateFrontMatter(draft) {
+    const updatedFrontMatter = this.frontMatter.update(draft);
+    return _DocContentMdValue.fromProps({
+      frontMatter: updatedFrontMatter.data || {},
+      content: this.content
+    }).text;
+  }
+  /**
+   * 新しいフロントマターでOpenMarkdownインスタンスを作成
+   */
+  withFrontMatter(frontMatter) {
+    return _DocContentMdValue.fromProps({
+      frontMatter,
+      content: this.content
+    });
+  }
+  /**
+   * フロントマターを更新した新しいOpenMarkdownインスタンスを作成
+   */
+  withUpdatedFrontMatter(draft) {
+    const updatedFrontMatter = this.frontMatter.update(draft);
+    return this.withFrontMatter(updatedFrontMatter.data || {});
+  }
+  /**
+   * マークダウンをtitle、description、本文の3つの部分に分離する
+   */
+  parseContentParts() {
+    const content = this.content;
+    const h1Match = content.match(/^#\s+(.+)$/m);
+    if (!h1Match) {
+      const paragraphMatch2 = content.match(
+        /^(\s*)([^#\n*-][^\n]*(?:\n(?![#\s*-])[^\n]*)*)(.*)/ms
+      );
+      if (paragraphMatch2) {
+        const [, , descriptionPart, remaining] = paragraphMatch2;
+        return {
+          title: null,
+          description: descriptionPart?.trim() ?? "",
+          body: remaining?.trim() ?? ""
+        };
+      }
+      return {
+        title: null,
+        description: null,
+        body: content.trim()
+      };
+    }
+    const title = h1Match[1]?.trim() ?? "";
+    const h1EndIndex = (h1Match.index ?? 0) + h1Match[0].length;
+    const afterH1 = content.substring(h1EndIndex);
+    const paragraphMatch = afterH1.match(
+      /^(\s*\n*)([^#\n*-][^\n]*(?:\n(?![#\s*-])[^\n]*)*)(.*)/ms
+    );
+    if (paragraphMatch) {
+      const [, , descriptionPart, remaining] = paragraphMatch;
+      return {
+        title,
+        description: descriptionPart?.trim() ?? "",
+        body: remaining?.trim() ?? ""
+      };
+    }
+    return {
+      title,
+      description: null,
+      body: afterH1.trim()
+    };
+  }
+  /**
+   * title、description、本文からマークダウンを構築する
+   */
+  buildContent(title, description, body) {
+    const parts = [];
+    if (title) {
+      parts.push(`# ${title}`);
+    }
+    if (description) {
+      parts.push(description);
+    }
+    if (body) {
+      parts.push(body);
+    }
+    return parts.join("\n\n");
+  }
+  /**
+   * H1タイトルを更新した新しいOpenMarkdownインスタンスを作成
+   */
+  withTitle(newTitle) {
+    const { description, body } = this.parseContentParts();
+    const updatedContent = this.buildContent(newTitle, description, body);
+    const frontMatterData = this.frontMatter.data !== null ? this.frontMatter.data : {};
+    return _DocContentMdValue.fromProps({
+      frontMatter: frontMatterData,
+      content: updatedContent
+    });
+  }
+  /**
+   * H1の次のdescription段落を更新した新しいOpenMarkdownインスタンスを作成
+   * @param newDescription 新しいdescription
+   * @param defaultTitle H1がない場合に使用するデフォルトタイトル
+   */
+  withDescription(newDescription, defaultTitle) {
+    const { title, body } = this.parseContentParts();
+    const finalTitle = title || defaultTitle;
+    if (!finalTitle) {
+      return this;
+    }
+    const updatedContent = this.buildContent(finalTitle, newDescription, body);
+    const frontMatterData = this.frontMatter.data !== null ? this.frontMatter.data : {};
+    return _DocContentMdValue.fromProps({
+      frontMatter: frontMatterData,
+      content: updatedContent
+    });
+  }
+};
+
+// lib/values/doc-schema-field-boolean-multiple-value.ts
+var DocSchemaFieldBooleanMultipleValue = class {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+    Object.freeze(this);
+    Object.freeze(this.value);
+    if (this.value.default) {
+      Object.freeze(this.value.default);
+    }
+  }
+  get type() {
+    return this.value.type;
+  }
+  get required() {
+    return this.value.required;
+  }
+  get title() {
+    return this.value.title ?? "";
+  }
+  get description() {
+    return this.value.description ?? "";
+  }
+  get default() {
+    return this.value.default;
+  }
+  isArray = true;
+  isSingle = false;
+  isBoolean = true;
+  /**
+   * 値を検証する
+   */
+  validate(value) {
+    return Array.isArray(value) && value.every((v) => typeof v === "boolean");
+  }
+  toJson() {
+    return { ...this.value };
+  }
+};
+
+// lib/values/doc-schema-field-boolean-single-value.ts
+var DocSchemaFieldBooleanSingleValue = class {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+    Object.freeze(this);
+  }
+  get type() {
+    return this.value.type;
+  }
+  get required() {
+    return this.value.required;
+  }
+  get title() {
+    return this.value.title ?? "";
+  }
+  get description() {
+    return this.value.description ?? "";
+  }
+  get default() {
+    return this.value.default;
+  }
+  isArray = false;
+  isSingle = true;
+  isBoolean = true;
+  toJson() {
+    return { ...this.value };
+  }
+  /**
+   * 値の型を検証する
+   */
+  validate(value) {
+    return typeof value === "boolean";
+  }
+};
+
+// lib/values/doc-schema-field-number-multiple-value.ts
+var DocSchemaFieldNumberMultipleValue = class {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+    Object.freeze(this);
+    Object.freeze(this.value);
+    if (this.value.default) {
+      Object.freeze(this.value.default);
+    }
+  }
+  get type() {
+    return this.value.type;
+  }
+  get required() {
+    return this.value.required;
+  }
+  get title() {
+    return this.value.title ?? "";
+  }
+  get description() {
+    return this.value.description ?? "";
+  }
+  get default() {
+    return this.value.default;
+  }
+  isArray = true;
+  isSingle = false;
+  isNumber = true;
+  /**
+   * 値を検証する
+   */
+  validate(value) {
+    return Array.isArray(value) && value.every((v) => typeof v === "number");
+  }
+  toJson() {
+    return { ...this.value };
+  }
+};
+
+// lib/values/doc-schema-field-number-single-value.ts
+var DocSchemaFieldNumberSingleValue = class {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+    Object.freeze(this);
+  }
+  get type() {
+    return this.value.type;
+  }
+  get required() {
+    return this.value.required;
+  }
+  get title() {
+    return this.value.title ?? "";
+  }
+  get description() {
+    return this.value.description ?? "";
+  }
+  get default() {
+    return this.value.default;
+  }
+  isArray = false;
+  isSingle = true;
+  isNumber = true;
+  toJson() {
+    return { ...this.value };
+  }
+  /**
+   * 値の型を検証する
+   */
+  validate(value) {
+    return typeof value === "number";
+  }
+};
+
+// lib/values/doc-schema-field-relation-multiple-value.ts
+var DocSchemaFieldRelationMultipleValue = class {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+    Object.freeze(this.value);
+    if (this.value.default && Array.isArray(this.value.default)) {
+      Object.freeze(this.value.default);
+    }
+    Object.freeze(this);
+  }
+  get type() {
+    return this.value.type;
+  }
+  get required() {
+    return this.value.required;
+  }
+  get title() {
+    return this.value.title ?? "";
+  }
+  get description() {
+    return this.value.description ?? "";
+  }
+  get default() {
+    return this.value.default;
+  }
+  get path() {
+    return this.value.path;
+  }
+  isArray = true;
+  isSingle = false;
+  isRelation = true;
+  /**
+   * 値を検証する
+   */
+  validate(value) {
+    return Array.isArray(value) && value.every((v) => typeof v === "string");
+  }
+  toJson() {
+    return { ...this.value };
+  }
+};
+
+// lib/values/doc-schema-field-relation-single-value.ts
+var DocSchemaFieldRelationSingleValue = class {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+    Object.freeze(this);
+  }
+  get type() {
+    return this.value.type;
+  }
+  get required() {
+    return this.value.required;
+  }
+  get title() {
+    return this.value.title ?? "";
+  }
+  get description() {
+    return this.value.description ?? "";
+  }
+  get default() {
+    return this.value.default;
+  }
+  get path() {
+    return this.value.path;
+  }
+  isArray = false;
+  isSingle = true;
+  isRelation = true;
+  toJson() {
+    return { ...this.value };
+  }
+  /**
+   * 値の型を検証する
+   */
+  validate(value) {
+    return typeof value === "string";
+  }
+};
+
+// lib/values/doc-schema-field-select-number-multiple-value.ts
+var DocSchemaFieldSelectNumberMultipleValue = class {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+    Object.freeze(this);
+    Object.freeze(this.value);
+    Object.freeze(this.value.options);
+    if (this.value.default && Array.isArray(this.value.default)) {
+      Object.freeze(this.value.default);
+    }
+  }
+  get type() {
+    return this.value.type;
+  }
+  get required() {
+    return this.value.required;
+  }
+  get title() {
+    return this.value.title ?? "";
+  }
+  get description() {
+    return this.value.description ?? "";
+  }
+  get default() {
+    return this.value.default;
+  }
+  get options() {
+    return this.value.options;
+  }
+  isArray = true;
+  isSingle = false;
+  isSelect = true;
+  isNumberSelect = true;
+  /**
+   * 値を検証する
+   */
+  validate(value) {
+    return Array.isArray(value) && value.every((v) => typeof v === "number");
+  }
+  toJson() {
+    return { ...this.value };
+  }
+};
+
+// lib/values/doc-schema-field-select-number-single-value.ts
+var DocSchemaFieldSelectNumberSingleValue = class {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+    Object.freeze(this);
+    Object.freeze(this.value);
+    Object.freeze(this.value.options);
+  }
+  get type() {
+    return this.value.type;
+  }
+  get required() {
+    return this.value.required;
+  }
+  get title() {
+    return this.value.title ?? "";
+  }
+  get description() {
+    return this.value.description ?? "";
+  }
+  get default() {
+    return this.value.default;
+  }
+  get options() {
+    return this.value.options;
+  }
+  isArray = false;
+  isSingle = true;
+  isSelect = true;
+  isNumberSelect = true;
+  /**
+   * 値を検証する
+   */
+  validate(value) {
+    return typeof value === "number";
+  }
+  toJson() {
+    return { ...this.value };
+  }
+};
+
+// lib/values/doc-schema-field-select-text-multiple-value.ts
+var DocSchemaFieldSelectTextMultipleValue = class {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+    Object.freeze(this);
+    Object.freeze(this.value);
+    Object.freeze(this.value.options);
+    if (this.value.default && Array.isArray(this.value.default)) {
+      Object.freeze(this.value.default);
+    }
+  }
+  get type() {
+    return this.value.type;
+  }
+  get required() {
+    return this.value.required;
+  }
+  get title() {
+    return this.value.title ?? "";
+  }
+  get description() {
+    return this.value.description ?? "";
+  }
+  get default() {
+    return this.value.default;
+  }
+  get options() {
+    return this.value.options;
+  }
+  isArray = true;
+  isSingle = false;
+  isSelect = true;
+  isTextSelect = true;
+  /**
+   * 値を検証する
+   */
+  validate(value) {
+    return Array.isArray(value) && value.every((v) => typeof v === "string");
+  }
+  toJson() {
+    return { ...this.value };
+  }
+};
+
+// lib/values/doc-schema-field-select-text-single-value.ts
+var DocSchemaFieldSelectTextSingleValue = class {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+    if (this.value.options) {
+      Object.freeze(this.value.options);
+    }
+    Object.freeze(this.value);
+    Object.freeze(this);
+  }
+  get type() {
+    return this.value.type;
+  }
+  get required() {
+    return this.value.required;
+  }
+  get title() {
+    return this.value.title ?? "";
+  }
+  get description() {
+    return this.value.description ?? "";
+  }
+  get default() {
+    return this.value.default;
+  }
+  get options() {
+    return this.value.options;
+  }
+  isArray = false;
+  isSingle = true;
+  isSelect = true;
+  isTextSelect = true;
+  toJson() {
+    return { ...this.value };
+  }
+  /**
+   * 値の型を検証する
+   */
+  validate(value) {
+    return typeof value === "string";
+  }
+};
+
+// lib/values/doc-schema-field-text-multiple-value.ts
+var DocSchemaFieldTextMultipleValue = class {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+    Object.freeze(this);
+    Object.freeze(this.value);
+    if (this.value.default) {
+      Object.freeze(this.value.default);
+    }
+  }
+  get type() {
+    return this.value.type;
+  }
+  get required() {
+    return this.value.required;
+  }
+  get title() {
+    return this.value.title ?? "";
+  }
+  get description() {
+    return this.value.description ?? "";
+  }
+  get default() {
+    return this.value.default;
+  }
+  isArray = true;
+  isSingle = false;
+  isText = true;
+  toJson() {
+    return { ...this.value };
+  }
+  /**
+   * 値の型を検証する
+   */
+  validate(value) {
+    return Array.isArray(value) && value.every((v) => typeof v === "string");
+  }
+};
+
+// lib/values/doc-schema-field-text-single-value.ts
+var DocSchemaFieldTextSingleValue = class {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+    Object.freeze(this);
+  }
+  get type() {
+    return this.value.type;
+  }
+  get required() {
+    return this.value.required;
+  }
+  get title() {
+    return this.value.title ?? "";
+  }
+  get description() {
+    return this.value.description ?? "";
+  }
+  get default() {
+    return this.value.default;
+  }
+  isArray = false;
+  isSingle = true;
+  isText = true;
+  toJson() {
+    return { ...this.value };
+  }
+  /**
+   * 値の型を検証する
+   */
+  validate(value) {
+    return typeof value === "string";
+  }
+};
+
+// lib/values/doc-schema-field-type-value.ts
+var DocSchemaFieldTypeValue = class _DocSchemaFieldTypeValue {
+  constructor(value) {
+    this.value = value;
+    zDocSchemaFieldType.parse(value);
+    Object.freeze(this);
+  }
+  /**
+   * タイプ値を取得
+   */
+  get type() {
+    return this.value;
+  }
+  /**
+   * テキスト型かどうか
+   */
+  get isText() {
+    return this.value === "text";
+  }
+  /**
+   * 数値型かどうか
+   */
+  get isNumber() {
+    return this.value === "number";
+  }
+  /**
+   * ブール型かどうか
+   */
+  get isBoolean() {
+    return this.value === "boolean";
+  }
+  /**
+   * 選択型（単一）かどうか
+   */
+  get isSelect() {
+    return this.value === "select-text" || this.value === "select-number";
+  }
+  /**
+   * リレーション型かどうか
+   */
+  get isRelation() {
+    return this.value === "relation" || this.value === "multi-relation";
+  }
+  /**
+   * 配列型かどうか
+   */
+  get isArray() {
+    return this.value === "multi-text" || this.value === "multi-number" || this.value === "multi-boolean" || this.value === "multi-relation" || this.value === "multi-select-text" || this.value === "multi-select-number";
+  }
+  /**
+   * 単一値型かどうか
+   */
+  get isSingle() {
+    return !this.isArray;
+  }
+  /**
+   * 基本型を取得（multi-textの場合はtext）
+   */
+  get baseType() {
+    if (this.value.startsWith("multi-")) {
+      return this.value.replace("multi-", "");
+    }
+    if (this.value.startsWith("select-")) {
+      return this.value.replace("select-", "");
+    }
+    return this.value;
+  }
+  /**
+   * デフォルト値を取得
+   */
+  getDefaultValue() {
+    if (this.isArray) return [];
+    if (this.isText) return "";
+    if (this.isNumber) return 0;
+    if (this.isBoolean) return false;
+    if (this.isRelation) return "";
+    return "";
+  }
+  /**
+   * 値の検証
+   */
+  validateValue(value) {
+    if (this.isArray) {
+      if (!Array.isArray(value)) return false;
+      const baseType = this.baseType;
+      return value.every((item) => {
+        if (baseType === "text") return typeof item === "string";
+        if (baseType === "number") return typeof item === "number";
+        if (baseType === "boolean") return typeof item === "boolean";
+        return true;
+      });
+    }
+    if (this.isText) return typeof value === "string";
+    if (this.isNumber) return typeof value === "number";
+    if (this.isBoolean) return typeof value === "boolean";
+    if (this.isRelation) return typeof value === "string";
+    return true;
+  }
+  /**
+   * 文字列から生成
+   */
+  static from(type) {
+    const validatedType = zDocSchemaFieldType.parse(type);
+    return new _DocSchemaFieldTypeValue(validatedType);
+  }
+  /**
+   * JSON形式に変換
+   */
+  toJson() {
+    return this.value;
+  }
+};
+
+// lib/values/doc-schema-field-factory.ts
+var DocSchemaFieldFactory = class {
+  constructor() {
+    Object.freeze(this);
+  }
+  /**
+   * スキーマエントリから適切な型のフィールドを生成
+   */
+  fromSchemaEntry(key, field) {
+    if (field.type === "text") {
+      return new DocSchemaFieldTextSingleValue(key, field);
+    }
+    if (field.type === "multi-text") {
+      return new DocSchemaFieldTextMultipleValue(key, field);
+    }
+    if (field.type === "number") {
+      return new DocSchemaFieldNumberSingleValue(key, field);
+    }
+    if (field.type === "multi-number") {
+      return new DocSchemaFieldNumberMultipleValue(key, field);
+    }
+    if (field.type === "boolean") {
+      return new DocSchemaFieldBooleanSingleValue(key, field);
+    }
+    if (field.type === "multi-boolean") {
+      return new DocSchemaFieldBooleanMultipleValue(key, field);
+    }
+    if (field.type === "select-text") {
+      return new DocSchemaFieldSelectTextSingleValue(key, field);
+    }
+    if (field.type === "select-number") {
+      return new DocSchemaFieldSelectNumberSingleValue(key, field);
+    }
+    if (field.type === "multi-select-text") {
+      return new DocSchemaFieldSelectTextMultipleValue(key, field);
+    }
+    if (field.type === "multi-select-number") {
+      return new DocSchemaFieldSelectNumberMultipleValue(key, field);
+    }
+    if (field.type === "relation") {
+      return new DocSchemaFieldRelationSingleValue(key, field);
+    }
+    if (field.type === "multi-relation") {
+      return new DocSchemaFieldRelationMultipleValue(key, field);
+    }
+    throw new Error("Unknown field type");
+  }
+  /**
+   * 未検証のデータから正規化して生成
+   */
+  fromUnknown(key, data) {
+    const normalized = this.normalizeField(data);
+    const validated = zDocSchemaField.parse(normalized);
+    return this.fromSchemaEntry(key, validated);
+  }
+  /**
+   * フィールド定義を正規化
+   */
+  normalizeField(field) {
+    if (!field || typeof field !== "object") {
+      return this.createDefaultTextField();
+    }
+    const fieldType = this.getFieldProperty(field, "type");
+    const fieldRequired = this.getFieldProperty(field, "required");
+    const fieldTitle = this.getFieldProperty(field, "title");
+    const fieldDescription = this.getFieldProperty(field, "description");
+    const fieldDefault = this.getFieldProperty(field, "default");
+    const normalizedType = this.normalizeType(fieldType);
+    const typeValue = DocSchemaFieldTypeValue.from(normalizedType);
+    const baseField = {
+      type: normalizedType,
+      required: fieldRequired ?? false,
+      title: fieldTitle,
+      description: fieldDescription,
+      default: fieldDefault
+    };
+    return {
+      ...baseField,
+      ...this.getTypeSpecificDefaults(field, typeValue)
+    };
+  }
+  /**
+   * デフォルトのテキストフィールドを作成
+   */
+  createDefaultTextField() {
+    return {
+      type: "text",
+      required: false,
+      title: "",
+      description: "",
+      default: ""
+    };
+  }
+  /**
+   * 型名を正規化
+   */
+  normalizeType(type) {
+    if (typeof type !== "string") return "text";
+    if (type === "string") return "text";
+    if (type === "multi-string") return "multi-text";
+    return type;
+  }
+  /**
+   * オブジェクトからプロパティを安全に取得
+   */
+  getFieldProperty(obj, key) {
+    if (Object.hasOwn(obj, key)) {
+      return Object.getOwnPropertyDescriptor(obj, key)?.value;
+    }
+    return null;
+  }
+  /**
+   * 型固有のデフォルト値を取得（イミュータブル）
+   */
+  getTypeSpecificDefaults(field, fieldType) {
+    const defaults = {};
+    if (fieldType.isRelation) {
+      defaults.path = this.getFieldProperty(field, "path") ?? "";
+    }
+    if (fieldType.isSelect) {
+      defaults.options = this.getFieldProperty(field, "options") ?? [];
+    }
+    return defaults;
+  }
+};
+
+// lib/values/doc-front-matter-md-value.ts
+var DocFrontMatterMdValue = class _DocFrontMatterMdValue {
+  constructor(value) {
+    this.value = value;
+    zDocFileMdFrontMatter.parse(value);
+    Object.freeze(this);
+  }
+  toJson() {
+    return this.value;
+  }
+  toYaml() {
+    return stringify2(this.value).trim();
+  }
+  /**
+   * Markdownテキストから生成
+   */
+  static from(markdownText) {
+    const openMarkdown = new DocContentMdValue(markdownText);
+    const rawData = openMarkdown.frontMatter.data || {};
+    const data = zDocFileMdFrontMatter.parse(rawData);
+    return new _DocFrontMatterMdValue(data);
+  }
+  /**
+   * 空のFrontMatterを生成
+   */
+  static empty() {
+    return new _DocFrontMatterMdValue({});
+  }
+  /**
+   * データから直接生成
+   */
+  static fromData(data) {
+    const validatedData = zDocFileMdFrontMatter.parse(data);
+    return new _DocFrontMatterMdValue(validatedData);
+  }
+  /**
+   * スキーマフィールドに基づいてデフォルト値を生成する
+   */
+  static generateDefaultValueFromSchemaField(fieldDef) {
+    if (fieldDef.type === "text") {
+      return fieldDef.default ?? "";
+    }
+    if (fieldDef.type === "boolean") {
+      return fieldDef.default ?? false;
+    }
+    if (fieldDef.type === "number") {
+      return fieldDef.default ?? 0;
+    }
+    if (fieldDef.type === "multi-text" || fieldDef.type === "multi-number" || fieldDef.type === "multi-boolean" || fieldDef.type === "multi-relation") {
+      return fieldDef.default ?? [];
+    }
+    if (fieldDef.type === "relation") {
+      return fieldDef.default ?? null;
+    }
+    return null;
+  }
+  /**
+   * 単一のプロパティを更新した新しいインスタンスを返す
+   * スキーマに基づいて型を検証し、スキーマのフィールドのみを含む新しいインスタンスを生成
+   */
+  withProperty(key, value, schema) {
+    const currentData = this.toJson();
+    const fieldValue = schema.field(key);
+    if (fieldValue === null) {
+      return this;
+    }
+    if (!this.validateFieldValue(key, value, fieldValue)) {
+      return this;
+    }
+    const draft = {};
+    for (const field of schema.fields) {
+      const fieldKey = field.key;
+      if (fieldKey === key) {
+        draft[fieldKey] = value;
+      } else if (fieldKey in currentData) {
+        const value2 = currentData[fieldKey];
+        if (value2 !== void 0) {
+          draft[fieldKey] = value2;
+        }
+      } else {
+        draft[fieldKey] = field.toJson().default;
+      }
+    }
+    return new _DocFrontMatterMdValue(draft);
+  }
+  /**
+   * フィールド値の検証
+   */
+  validateFieldValue(key, value, fieldDef) {
+    try {
+      const factory = new DocSchemaFieldFactory();
+      const schemaField = factory.fromSchemaEntry(key, fieldDef);
+      return schemaField.validate(value);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * テキスト型のプロパティを取得
+   */
+  text(key) {
+    const value = this.value[key];
+    const validator = new DocSchemaFieldTextSingleValue(key, {
+      type: "text",
+      required: false,
+      title: null,
+      description: null,
+      default: null
+    });
+    return validator.validate(value) && typeof value === "string" ? value : null;
+  }
+  /**
+   * 数値型のプロパティを取得
+   */
+  number(key) {
+    const value = this.value[key];
+    const validator = new DocSchemaFieldNumberSingleValue(key, {
+      type: "number",
+      required: false,
+      title: null,
+      description: null,
+      default: null
+    });
+    return validator.validate(value) && typeof value === "number" ? value : null;
+  }
+  /**
+   * 真偽値型のプロパティを取得
+   */
+  boolean(key) {
+    const value = this.value[key];
+    const validator = new DocSchemaFieldBooleanSingleValue(key, {
+      type: "boolean",
+      required: false,
+      title: null,
+      description: null,
+      default: null
+    });
+    return validator.validate(value) && typeof value === "boolean" ? value : null;
+  }
+  /**
+   * 単一リレーション型のプロパティを取得
+   */
+  relation(key) {
+    const value = this.value[key];
+    const validator = new DocSchemaFieldTextSingleValue(key, {
+      type: "text",
+      required: false,
+      title: null,
+      description: null,
+      default: null
+    });
+    return validator.validate(value) && typeof value === "string" ? value : null;
+  }
+  /**
+   * 複数リレーション型のプロパティを取得
+   */
+  multiRelation(key) {
+    const value = this.value[key];
+    const validator = new DocSchemaFieldTextMultipleValue(key, {
+      type: "multi-text",
+      required: false,
+      title: null,
+      description: null,
+      default: null
+    });
+    return validator.validate(value) && Array.isArray(value) ? value : [];
+  }
+  /**
+   * 複数テキスト型のプロパティを取得
+   */
+  multiText(key) {
+    const value = this.value[key];
+    const validator = new DocSchemaFieldTextMultipleValue(key, {
+      type: "multi-text",
+      required: false,
+      title: null,
+      description: null,
+      default: null
+    });
+    return validator.validate(value) && Array.isArray(value) ? value : [];
+  }
+  /**
+   * 複数数値型のプロパティを取得
+   */
+  multiNumber(key) {
+    const value = this.value[key];
+    const validator = new DocSchemaFieldNumberMultipleValue(key, {
+      type: "multi-number",
+      required: false,
+      title: null,
+      description: null,
+      default: null
+    });
+    return validator.validate(value) && Array.isArray(value) ? value : [];
+  }
+  /**
+   * 複数真偽値型のプロパティを取得
+   */
+  multiBoolean(key) {
+    const value = this.value[key];
+    const validator = new DocSchemaFieldBooleanMultipleValue(key, {
+      type: "multi-boolean",
+      required: false,
+      title: null,
+      description: null,
+      default: null
+    });
+    return validator.validate(value) && Array.isArray(value) ? value : [];
+  }
+  /**
+   * プロパティが存在するかチェック
+   */
+  has(key) {
+    return key in this.value && this.value[key] !== void 0;
+  }
+  /**
+   * すべてのキーを取得
+   */
+  get keys() {
+    return Object.keys(this.value);
+  }
+};
+
+// lib/values/doc-file-content-md-value.ts
+var DocFileContentMdValue = class _DocFileContentMdValue {
+  constructor(value) {
+    this.value = value;
+    zDocFileContentMd.parse(value);
+    Object.freeze(this);
+  }
+  /**
+   * コンテンツ本文（frontMatterを含まない）
+   */
+  get body() {
+    return this.value.body;
+  }
+  /**
+   * タイトル
+   */
+  get title() {
+    return this.value.title;
+  }
+  /**
+   * 説明
+   */
+  get description() {
+    return this.value.description;
+  }
+  /**
+   * FrontMatter
+   */
+  get frontMatter() {
+    return new DocFrontMatterMdValue(this.value.frontMatter);
+  }
+  /**
+   * タイトルを更新
+   */
+  withTitle(title) {
+    const fullText = this.toText();
+    const engine = new DocMarkdownSystem();
+    const updatedText = engine.updateTitle(fullText, title);
+    const updatedBody = engine.extractBody(updatedText);
+    return new _DocFileContentMdValue({
+      type: "markdown-content",
+      body: updatedBody,
+      title,
+      description: this.description,
+      frontMatter: this.value.frontMatter
+    });
+  }
+  /**
+   * 説明を更新
+   */
+  withDescription(description, defaultTitle) {
+    const fullText = this.toText();
+    const engine = new DocMarkdownSystem();
+    const updatedText = engine.updateDescription(
+      fullText,
+      description,
+      defaultTitle || this.title
+    );
+    const updatedBody = engine.extractBody(updatedText);
+    return new _DocFileContentMdValue({
+      type: "markdown-content",
+      body: updatedBody,
+      title: this.title,
+      description,
+      frontMatter: this.value.frontMatter
+    });
+  }
+  /**
+   * コンテンツを更新
+   */
+  withContent(content) {
+    const engine = new DocMarkdownSystem();
+    return new _DocFileContentMdValue({
+      type: "markdown-content",
+      body: content,
+      title: engine.extractTitle(content) || "",
+      description: engine.extractDescription(content) || "",
+      frontMatter: this.value.frontMatter
+    });
+  }
+  /**
+   * FrontMatterを更新
+   */
+  withFrontMatter(frontMatter) {
+    return new _DocFileContentMdValue({
+      type: "markdown-content",
+      body: this.body,
+      title: this.title,
+      description: this.description,
+      frontMatter: frontMatter.value
+    });
+  }
+  /**
+   * Markdownテキストから生成
+   */
+  static fromMarkdown(markdown) {
+    const engine = new DocMarkdownSystem();
+    const frontMatter = DocFrontMatterMdValue.from(markdown);
+    return new _DocFileContentMdValue({
+      type: "markdown-content",
+      body: engine.extractBody(markdown),
+      title: engine.extractTitle(markdown) || "",
+      description: engine.extractDescription(markdown) || "",
+      frontMatter: frontMatter.value
+    });
+  }
+  /**
+   * 完全なMarkdownテキストを生成
+   */
+  toMarkdownText() {
+    return DocMarkdownSystem.from(this.title, this.description, this.body);
+  }
+  /**
+   * FrontMatterとbodyを結合した完全なテキストを生成
+   */
+  toText() {
+    return `---
+${this.frontMatter.toYaml()}
+---
+
+${this.body}`;
+  }
+  /**
+   * 空のコンテンツを生成
+   */
+  static empty(title) {
+    return new _DocFileContentMdValue({
+      type: "markdown-content",
+      body: `# ${title}`,
+      title,
+      description: "",
+      frontMatter: {}
+    });
+  }
+  /**
+   * JSON形式で出力
+   */
+  toJson() {
+    return this.value;
+  }
+};
+
+// lib/entities/doc-file-md-entity.ts
+var DocFileMdEntity = class _DocFileMdEntity {
+  constructor(value) {
+    this.value = value;
+    zDocFileMd.parse(value);
+    Object.freeze(this);
+  }
+  /**
+   * コンテンツ
+   */
+  get content() {
+    return new DocFileContentMdValue(this.value.content);
+  }
+  /**
+   * パス情報
+   */
+  get path() {
+    return this.value.path;
+  }
+  /**
+   * コンテンツを更新
+   */
+  withContent(content) {
+    return new _DocFileMdEntity({
+      ...this.value,
+      content: content.value
+    });
+  }
+  /**
+   * パスを更新
+   */
+  withPath(path) {
+    return new _DocFileMdEntity({
+      ...this.value,
+      path
+    });
+  }
+  /**
+   * JSON形式に変換
+   */
+  toJson() {
+    return this.value;
+  }
+};
+
+// lib/values/doc-file-path-value.ts
+var DocFilePathValue = class _DocFilePathValue {
+  constructor(value, pathSystem) {
+    this.value = value;
+    zDocFilePath.parse(value);
+    this.pathSystem = pathSystem;
+    Object.freeze(this);
+  }
+  pathSystem;
+  /**
+   * ファイル名（拡張子なし）
+   */
+  get name() {
+    return this.value.name;
+  }
+  /**
+   * ファイルパス（相対パス）
+   */
+  get path() {
+    return this.value.path;
+  }
+  /**
+   * ファイル名（拡張子付き）
+   */
+  get nameWithExtension() {
+    return this.value.nameWithExtension;
+  }
+  /**
+   * フルパス（絶対パス）
+   */
+  get fullPath() {
+    return this.value.fullPath;
+  }
+  /**
+   * ディレクトリパス
+   */
+  get directoryPath() {
+    return this.pathSystem.dirname(this.path);
+  }
+  /**
+   * 拡張子
+   */
+  get extension() {
+    return this.pathSystem.extname(this.nameWithExtension);
+  }
+  /**
+   * アーカイブされているかどうか
+   */
+  get isArchived() {
+    return this.path.includes("/.archive/");
+  }
+  /**
+   * 相対パスからインスタンスを生成（DI対応）
+   */
+  static fromPathWithSystem(filePath, pathSystem, basePath) {
+    const nameWithExtension = pathSystem.basename(filePath);
+    let name = pathSystem.basename(filePath, pathSystem.extname(filePath));
+    if (name === "index" && filePath.includes("/")) {
+      const parentDir = pathSystem.dirname(filePath);
+      name = pathSystem.basename(parentDir);
+    }
+    const fullPath = basePath ? pathSystem.join(basePath, filePath) : pathSystem.resolve(filePath);
+    return new _DocFilePathValue(
+      {
+        name,
+        path: filePath,
+        fullPath,
+        nameWithExtension
+      },
+      pathSystem
+    );
+  }
+  /**
+   * JSON形式で出力
+   */
+  toJson() {
+    return this.value;
+  }
+};
+
+// lib/values/doc-relation-file-value.ts
+var DocRelationFileValue = class _DocRelationFileValue {
+  constructor(value) {
+    this.value = value;
+    zDocRelationFile.parse(value);
+    Object.freeze(this);
+    Object.freeze(this.value);
+  }
+  /**
+   * ファイルパス
+   */
+  get id() {
+    return this.value.name;
+  }
+  /**
+   * スラッグ
+   */
+  get slug() {
+    return this.value.name;
+  }
+  /**
+   * 表示用ラベル
+   */
+  get label() {
+    return this.value.label || this.value.name;
+  }
+  /**
+   * ファイルパスとタイトルから生成
+   */
+  static from(filePath, title) {
+    const fileName = _DocRelationFileValue.extractFileName(filePath);
+    return new _DocRelationFileValue({
+      name: fileName,
+      label: title || fileName,
+      value: null,
+      path: null
+    });
+  }
+  /**
+   * ファイルパスからファイル名を抽出（拡張子なし）
+   */
+  static extractFileName(filePath) {
+    return filePath.split("/").pop()?.replace(".md", "") || filePath;
+  }
+  /**
+   * JSON形式に変換
+   */
+  toJson() {
+    return { ...this.value };
+  }
+};
+
+// lib/values/doc-relation-value.ts
+var DocRelationValue = class _DocRelationValue {
+  constructor(value) {
+    this.value = value;
+    zDocRelation.parse(value);
+    Object.freeze(this);
+    Object.freeze(this.value);
+  }
+  /**
+   * リレーションパス
+   */
+  get path() {
+    return this.value.path;
+  }
+  /**
+   * リレーション対象ファイル一覧（値オブジェクト）
+   */
+  get files() {
+    return this.value.files.map((file) => new DocRelationFileValue(file));
+  }
+  /**
+   * ファイル数を取得
+   */
+  get fileCount() {
+    return this.files.length;
+  }
+  /**
+   * 空かどうか
+   */
+  get isEmpty() {
+    return this.files.length === 0;
+  }
+  /**
+   * 空のリレーションエンティティを作成
+   */
+  static empty(path) {
+    return new _DocRelationValue({
+      path,
+      files: []
+    });
+  }
+  /**
+   * JSON形式で出力
+   */
+  toJson() {
+    return {
+      path: this.path,
+      files: this.files.map((file) => file.toJson())
+    };
+  }
+};
+
+// lib/doc-file-relation-reference.ts
+var DocFileRelationReference = class {
+  constructor(props) {
+    this.props = props;
+    this.pathSystem = props.pathSystem;
+    Object.freeze(this);
+  }
+  pathSystem;
+  get fileSystem() {
+    return this.props.fileSystem;
+  }
+  get basePath() {
+    return this.fileSystem.getBasePath();
+  }
+  /**
+   * リレーションパス
+   */
+  get path() {
+    return this.props.filePath;
+  }
+  /**
+   * フルパス
+   */
+  get fullPath() {
+    return this.pathSystem.join(
+      this.fileSystem.getBasePath(),
+      this.props.filePath
+    );
+  }
+  async read() {
+    const files = await this.readFiles();
+    return new DocRelationValue({
+      path: this.path,
+      files: files.map((value) => value.toJson())
+    });
+  }
+  /**
+   * リレーションファイルの一覧を読み込む
+   */
+  async readFiles() {
+    const exists = await this.fileSystem.exists(this.path);
+    if (!exists) {
+      return [];
+    }
+    const filePaths = await this.fileSystem.readDirectoryFilePaths(this.path);
+    const files = [];
+    for (const filePath of filePaths) {
+      const file = await this.readFile(filePath);
+      if (file === null) continue;
+      files.push(file);
+    }
+    return files;
+  }
+  /**
+   * 単一のリレーションファイルを読み込む
+   */
+  async readFile(filePath) {
+    if (filePath.includes("index.md")) {
+      return null;
+    }
+    const content = await this.fileSystem.readFile(filePath);
+    if (content === null) {
+      return null;
+    }
+    const contentValue = DocFileContentMdValue.fromMarkdown(content);
+    const pathValue = DocFilePathValue.fromPathWithSystem(
+      filePath,
+      this.pathSystem,
+      this.basePath
+    );
+    const fileEntity = new DocFileMdEntity({
+      type: "markdown",
+      content: contentValue.value,
+      path: pathValue.value,
+      isArchived: false
+    });
+    return DocRelationFileValue.from(filePath, fileEntity.value.content.title);
+  }
+  /**
+   * ファイルの存在確認
+   */
+  async exists(slug) {
+    const filePath = `${this.path}/${slug}.md`;
+    return this.fileSystem.exists(filePath);
+  }
+  /**
+   * ファイル名の一覧を取得（拡張子なし）
+   */
+  async readSlugs() {
+    const files = await this.readFiles();
+    return files.map((file) => file.id);
+  }
+  /**
+   * ファイル数を取得
+   */
+  async count() {
+    const files = await this.readFiles();
+    return files.length;
+  }
+  /**
+   * 空かどうかを確認
+   */
+  async isEmpty() {
+    const count = await this.count();
+    return count === 0;
+  }
+};
+
+// lib/values/doc-front-matter-index-value.ts
+import { parse as parse2, stringify as stringify3 } from "yaml";
+
+// lib/values/doc-schema-value.ts
+var DocSchemaValue = class _DocSchemaValue {
+  constructor(value) {
+    this.value = value;
+    zDocSchema.parse(value);
+    Object.freeze(this.value);
+    Object.freeze(this);
+  }
+  /**
+   * フィールド名の一覧を取得
+   */
+  get fieldNames() {
+    return Object.keys(this.value);
+  }
+  /**
+   * 指定されたフィールド名のフィールドを取得
+   */
+  field(name) {
+    const fieldDef = this.value[name];
+    if (fieldDef === void 0) {
+      return null;
+    }
+    const factory = new DocSchemaFieldFactory();
+    return factory.fromSchemaEntry(name, fieldDef);
+  }
+  get fields() {
+    const factory = new DocSchemaFieldFactory();
+    return this.fieldNames.map((name) => {
+      const fieldValue = this.value[name];
+      if (!fieldValue) {
+        throw new Error(`Field ${name} not found in schema`);
+      }
+      return factory.fromSchemaEntry(name, fieldValue);
+    });
+  }
+  get relationFields() {
+    return this.fields.filter((t) => {
+      return t instanceof DocSchemaFieldRelationSingleValue || t instanceof DocSchemaFieldRelationMultipleValue;
+    });
+  }
+  /**
+   * 空のスキーマエンティティを作成
+   */
+  static empty() {
+    return new _DocSchemaValue({});
+  }
+  /**
+   * スキーマからリレーションパスを抽出
+   */
+  extractRelationPaths() {
+    if (!this.value) return /* @__PURE__ */ new Set();
+    const uniqueRelationPaths = /* @__PURE__ */ new Set();
+    for (const field of Object.values(this.value)) {
+      if (this.isRelationField(field) && "path" in field) {
+        uniqueRelationPaths.add(field.path);
+      }
+    }
+    return uniqueRelationPaths;
+  }
+  /**
+   * フィールドがリレーション型かどうかを判定
+   */
+  isRelationField(field) {
+    return field.type === "relation" || field.type === "multi-relation";
+  }
+  /**
+   * リレーションオプションを作成
+   */
+  createRelationOption(filePath, title) {
+    const fileName = this.extractFileName(filePath);
+    return zDocRelationFile.parse({
+      name: fileName,
+      label: title || fileName,
+      value: fileName,
+      path: filePath
+    });
+  }
+  /**
+   * ファイルをスキップすべきかどうかを判定
+   */
+  shouldSkipFile(filePath) {
+    return filePath.endsWith("index.md") || filePath.endsWith("README.md");
+  }
+  /**
+   * 値を指定された型に変換する（デフォルト値フォールバック付き）
+   */
+  convertValue(value, targetType, defaultValue) {
+    if (this.isNullOrUndefined(value)) {
+      return defaultValue;
+    }
+    try {
+      return this.convertByType(value, targetType, defaultValue);
+    } catch {
+      return defaultValue;
+    }
+  }
+  /**
+   * 型別の変換処理
+   */
+  convertByType(value, targetType, defaultValue) {
+    if (targetType === "text") {
+      return this.convertToString(value, defaultValue);
+    }
+    if (targetType === "number") {
+      return this.convertToNumber(value, defaultValue);
+    }
+    if (targetType === "boolean") {
+      return this.convertToBoolean(value, defaultValue);
+    }
+    if (targetType === "multi-text" || targetType === "array") {
+      return this.convertToArray(value, defaultValue);
+    }
+    if (targetType === "relation") {
+      return this.convertToRelation(value, defaultValue);
+    }
+    if (targetType === "multi-relation") {
+      return this.convertToMultiRelation(value, defaultValue);
+    }
+    return defaultValue;
+  }
+  /**
+   * 文字列型への変換
+   */
+  convertToString(value, defaultValue) {
+    if (typeof value === "string") return value;
+    if (typeof value === "number") return String(value);
+    if (typeof value === "boolean") return String(value);
+    return defaultValue;
+  }
+  /**
+   * 数値型への変換
+   */
+  convertToNumber(value, defaultValue) {
+    if (typeof value === "number") return value;
+    if (typeof value === "string") {
+      const parsed = Number(value);
+      return Number.isNaN(parsed) ? defaultValue : parsed;
+    }
+    if (typeof value === "boolean") return value ? 1 : 0;
+    return defaultValue;
+  }
+  /**
+   * ブール型への変換
+   */
+  convertToBoolean(value, defaultValue) {
+    if (typeof value === "boolean") return value;
+    if (typeof value === "string") {
+      const lower = value.toLowerCase();
+      if (lower === "true" || lower === "1") return true;
+      if (lower === "false" || lower === "0") return false;
+      return defaultValue;
+    }
+    if (typeof value === "number") return value !== 0;
+    return defaultValue;
+  }
+  /**
+   * 配列型への変換
+   */
+  convertToArray(value, defaultValue) {
+    if (Array.isArray(value)) return value;
+    if (typeof value === "string") {
+      return value.split(",").map((item) => item.trim());
+    }
+    return defaultValue;
+  }
+  /**
+   * リレーション型への変換
+   */
+  convertToRelation(value, defaultValue) {
+    if (typeof value === "string") {
+      return this.extractFileNameFromPath(value);
+    }
+    return defaultValue;
+  }
+  /**
+   * マルチリレーション型への変換
+   */
+  convertToMultiRelation(value, defaultValue) {
+    if (Array.isArray(value)) {
+      return value.filter((item) => typeof item === "string").map((item) => this.extractFileNameFromPath(item));
+    }
+    if (typeof value === "string") {
+      return value.split(",").map((item) => this.extractFileNameFromPath(item.trim()));
+    }
+    return defaultValue;
+  }
+  /**
+   * パスからファイル名を抽出（拡張子除去）
+   */
+  extractFileNameFromPath(path) {
+    const fileName = path.split("/").pop() || path;
+    return fileName.replace(/\.md$/, "");
+  }
+  /**
+   * スキーマベースでFrontMatterを補完する
+   */
+  getCompleteFrontMatter(rawFrontMatter) {
+    const defaultFrontMatter = this.generateDefaultFrontMatter();
+    return this.mergePreservingExistingValues(
+      defaultFrontMatter,
+      rawFrontMatter
+    );
+  }
+  /**
+   * スキーマからデフォルトFrontMatterを生成
+   */
+  generateDefaultFrontMatter() {
+    if (!this.value) return {};
+    const defaultFrontMatter = {};
+    for (const [key, field] of Object.entries(this.value)) {
+      defaultFrontMatter[key] = DocFrontMatterMdValue.generateDefaultValueFromSchemaField(field);
+    }
+    return zDocFileMdFrontMatter.parse(defaultFrontMatter);
+  }
+  /**
+   * 既存の値を保持しながらマージ
+   */
+  mergePreservingExistingValues(defaults, existing) {
+    const result = { ...defaults };
+    if (existing && typeof existing === "object") {
+      const validatedData = zDocFileMdFrontMatter.parse(existing);
+      for (const [key, value] of Object.entries(validatedData)) {
+        if (value !== void 0 && value !== null) {
+          result[key] = value;
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * ファイルパスからファイル名を抽出（拡張子なし）
+   */
+  extractFileName(filePath) {
+    return filePath.split("/").pop()?.replace(".md", "") || filePath;
+  }
+  /**
+   * nullまundefinedのチェック
+   */
+  isNullOrUndefined(value) {
+    return value === null || value === void 0;
+  }
+  toJson() {
+    return this.value;
+  }
+};
+
+// lib/values/doc-front-matter-index-value.ts
+var DocFrontMatterIndexValue = class _DocFrontMatterIndexValue {
+  constructor(value) {
+    this.value = value;
+    zDocFileIndexFrontMatter.parse(value);
+    Object.freeze(this);
+  }
+  /**
+   * アイコンを取得
+   */
+  get icon() {
+    return this.value.icon;
+  }
+  /**
+   * スキーマを取得
+   */
+  get schema() {
+    return new DocSchemaValue(this.value.schema);
+  }
+  /**
+   * iconフィールドを更新
+   */
+  withIcon(value) {
+    if (typeof value !== "string") {
+      return this;
+    }
+    const currentData = this.toJson();
+    return _DocFrontMatterIndexValue.fromRecord({
+      ...currentData,
+      icon: value
+    });
+  }
+  /**
+   * schemaフィールドを更新
+   */
+  withSchema(value) {
+    if (typeof value !== "object" || value === null) {
+      return this;
+    }
+    const currentData = this.toJson();
+    return _DocFrontMatterIndexValue.fromRecord({
+      ...currentData,
+      schema: _DocFrontMatterIndexValue.createSchema(value)
+    });
+  }
+  /**
+   * JSON形式で出力
+   */
+  toJson() {
+    return this.value;
+  }
+  /**
+   * YAML形式で出力
+   */
+  toYaml() {
+    const yamlData = {
+      icon: this.value.icon,
+      schema: this.value.schema
+    };
+    return stringify3(yamlData).trim();
+  }
+  /**
+   * スキーマ全体を正規化
+   */
+  static createSchema(schema) {
+    if (typeof schema !== "object" || schema === null) {
+      return {};
+    }
+    const schemaObj = schema;
+    const record = {};
+    for (const [key, value] of Object.entries(schemaObj)) {
+      const normalizedField = _DocFrontMatterIndexValue.createSchemaField(
+        key,
+        value
+      );
+      if (normalizedField === null) continue;
+      record[key] = normalizedField;
+    }
+    return record;
+  }
+  /**
+   * スキーマフィールドを正規化
+   */
+  static createSchemaField(key, value) {
+    try {
+      const factory = new DocSchemaFieldFactory();
+      const fieldValue = factory.fromUnknown(key, value);
+      return fieldValue.toJson();
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Markdownテキストから生成（不完全なデータも処理可能）
+   */
+  static from(markdownText) {
+    if (!markdownText.startsWith("---")) {
+      return _DocFrontMatterIndexValue.empty();
+    }
+    const endIndex = markdownText.indexOf("\n---", 3);
+    if (endIndex === -1) {
+      return _DocFrontMatterIndexValue.empty();
+    }
+    const frontMatterText = markdownText.slice(4, endIndex).trim();
+    try {
+      const data = parse2(frontMatterText) || {};
+      return _DocFrontMatterIndexValue.fromRecord(data);
+    } catch {
+      return _DocFrontMatterIndexValue.empty();
+    }
+  }
+  /**
+   * データから直接生成（不完全なデータも処理可能）
+   */
+  static fromRecord(record) {
+    if (typeof record !== "object") {
+      return _DocFrontMatterIndexValue.empty();
+    }
+    const icon = _DocFrontMatterIndexValue.extractIcon(record);
+    const schema = _DocFrontMatterIndexValue.extractSchema(record);
+    const frontMatter = {
+      type: "index-frontmatter",
+      icon,
+      schema
+    };
+    try {
+      const validated = zDocFileIndexFrontMatter.parse(frontMatter);
+      return new _DocFrontMatterIndexValue(validated);
+    } catch {
+      return _DocFrontMatterIndexValue.empty();
+    }
+  }
+  /**
+   * 空のFrontMatterを生成
+   */
+  static empty() {
+    return new _DocFrontMatterIndexValue({
+      type: "index-frontmatter",
+      icon: "",
+      schema: {}
+    });
+  }
+  /**
+   * アイコンを抽出
+   */
+  static extractIcon(data) {
+    if ("icon" in data && typeof data.icon === "string") {
+      return data.icon;
+    }
+    return _DocFrontMatterIndexValue.getDefaultIcon();
+  }
+  /**
+   * スキーマを抽出
+   */
+  static extractSchema(data) {
+    const hasSchema = "schema" in data;
+    if (!hasSchema) {
+      return {};
+    }
+    if (typeof data.schema !== "object") {
+      return {};
+    }
+    if (data.schema === null) {
+      return {};
+    }
+    return _DocFrontMatterIndexValue.createSchema(data.schema);
+  }
+  /**
+   * デフォルトのアイコンを取得
+   */
+  static getDefaultIcon() {
+    return "\u{1F4C3}";
+  }
+};
+
+// lib/values/doc-file-content-index-value.ts
+var DocFileContentIndexValue = class _DocFileContentIndexValue {
+  constructor(value) {
+    this.value = value;
+    zDocFileContentIndex.parse(value);
+    Object.freeze(this);
+  }
+  /**
+   * コンテンツ本文（frontMatterを含まない）
+   */
+  get body() {
+    return this.value.body;
+  }
+  /**
+   * タイトル
+   */
+  get title() {
+    return this.value.title;
+  }
+  /**
+   * 説明
+   */
+  get description() {
+    return this.value.description;
+  }
+  /**
+   * FrontMatter
+   */
+  get frontMatter() {
+    return new DocFrontMatterIndexValue(this.value.frontMatter);
+  }
+  /**
+   * タイトルを更新
+   */
+  withTitle(title) {
+    const fullText = this.toText();
+    const engine = new DocMarkdownSystem();
+    const updatedText = engine.updateTitle(fullText, title);
+    const updatedBody = engine.extractBody(updatedText);
+    return new _DocFileContentIndexValue({
+      type: "markdown-index",
+      body: updatedBody,
+      title,
+      description: this.description,
+      frontMatter: this.value.frontMatter
+    });
+  }
+  /**
+   * 説明を更新
+   */
+  withDescription(description, defaultTitle) {
+    const fullText = this.toText();
+    const engine = new DocMarkdownSystem();
+    const updatedText = engine.updateDescription(
+      fullText,
+      description,
+      defaultTitle || this.title
+    );
+    const updatedBody = engine.extractBody(updatedText);
+    return new _DocFileContentIndexValue({
+      type: "markdown-index",
+      body: updatedBody,
+      title: this.title,
+      description,
+      frontMatter: this.value.frontMatter
+    });
+  }
+  /**
+   * Markdownテキストから生成
+   */
+  static fromMarkdown(markdown) {
+    const engine = new DocMarkdownSystem();
+    const frontMatter = DocFrontMatterIndexValue.from(markdown);
+    return new _DocFileContentIndexValue({
+      type: "markdown-index",
+      body: engine.extractBody(markdown),
+      title: engine.extractTitle(markdown) || "",
+      description: engine.extractDescription(markdown) || "",
+      frontMatter: frontMatter.toJson()
+    });
+  }
+  /**
+   * 完全なMarkdownテキストを生成
+   */
+  toMarkdownText() {
+    return DocMarkdownSystem.from(this.title, this.description, this.body);
+  }
+  /**
+   * コンテンツを更新
+   */
+  withContent(content) {
+    const engine = new DocMarkdownSystem();
+    return new _DocFileContentIndexValue({
+      type: "markdown-index",
+      body: content,
+      title: engine.extractTitle(content) || "",
+      description: engine.extractDescription(content) || "",
+      frontMatter: this.value.frontMatter
+    });
+  }
+  /**
+   * FrontMatterを更新
+   */
+  withFrontMatter(frontMatter) {
+    return new _DocFileContentIndexValue({
+      type: "markdown-index",
+      body: this.body,
+      title: this.title,
+      description: this.description,
+      frontMatter: frontMatter.toJson()
+    });
+  }
+  /**
+   * デフォルトのindex.mdコンテンツを生成
+   */
+  static empty(directoryName) {
+    const content = `---
+title: "${directoryName}"
+description: ""
+icon: ""
+schema: {}
+---
+
+# ${directoryName}
+`;
+    return _DocFileContentIndexValue.fromMarkdown(content);
+  }
+  /**
+   * FrontMatterとbodyを結合した完全なテキストを生成
+   */
+  toText() {
+    return `---
+${this.frontMatter.toYaml()}
+---
+
+${this.body}`;
+  }
+  /**
+   * JSON形式で出力
+   */
+  toJson() {
+    return this.value;
+  }
+};
+
+// lib/entities/doc-file-index-entity.ts
+var DocFileIndexEntity = class _DocFileIndexEntity {
+  constructor(value) {
+    this.value = value;
+    zDocFileIndex.parse(value);
+    Object.freeze(this);
+  }
+  /**
+   * コンテンツ
+   */
+  get content() {
+    return new DocFileContentIndexValue(this.value.content);
+  }
+  /**
+   * パス情報
+   */
+  get path() {
+    return this.value.path;
+  }
+  /**
+   * コンテンツを更新
+   */
+  withContent(content) {
+    return new _DocFileIndexEntity({
+      ...this.value,
+      content: content.value
+    });
+  }
+  /**
+   * パスを更新
+   */
+  withPath(path) {
+    return new _DocFileIndexEntity({
+      ...this.value,
+      path
+    });
+  }
+  /**
+   * indexFileSchemaの形式に変換
+   */
+  toJson() {
+    return this.value;
+  }
+};
+
+// lib/doc-file-index-reference.ts
+var DocFileIndexReference = class _DocFileIndexReference {
+  constructor(props) {
+    this.props = props;
+    this.pathSystem = props.pathSystem;
+    Object.freeze(this);
+  }
+  pathSystem;
+  get fileSystem() {
+    return this.props.fileSystem;
+  }
+  get basePath() {
+    return this.fileSystem.getBasePath();
+  }
+  get filePath() {
+    return this.props.path;
+  }
+  get fileFullPath() {
+    return this.pathSystem.join(this.basePath, this.filePath);
+  }
+  get durectoryPath() {
+    return this.pathSystem.dirname(this.filePath);
+  }
+  async read() {
+    const content = await this.fileSystem.readFile(this.filePath);
+    if (content === null) {
+      const dirName = this.filePath.split("/").pop() || "directory";
+      const pathValue2 = DocFilePathValue.fromPathWithSystem(
+        this.filePath,
+        this.pathSystem,
+        this.fileSystem.getBasePath()
+      );
+      const contentValue2 = DocFileContentIndexValue.empty(dirName);
+      return new DocFileIndexEntity({
+        type: "index",
+        path: pathValue2.toJson(),
+        content: contentValue2.toJson(),
+        isArchived: false
+      });
+    }
+    const pathValue = DocFilePathValue.fromPathWithSystem(
+      this.filePath,
+      this.pathSystem,
+      this.fileSystem.getBasePath()
+    );
+    const contentValue = DocFileContentIndexValue.fromMarkdown(content);
+    return new DocFileIndexEntity({
+      type: "index",
+      path: pathValue.toJson(),
+      content: contentValue.toJson(),
+      isArchived: false
+    });
+  }
+  /**
+   * ファイルの内容を読み込む
+   */
+  async readContent() {
+    const entity = await this.read();
+    if (entity instanceof Error) {
+      return entity;
+    }
+    return entity.value.content.body;
+  }
+  /**
+   * ファイルに内容を書き込む
+   */
+  async writeContent(content) {
+    await this.fileSystem.writeFile(this.filePath, content);
+  }
+  /**
+   * Entityを書き込む
+   */
+  async write(entity) {
+    const content = entity.content.toText();
+    await this.fileSystem.writeFile(this.filePath, content);
+  }
+  /**
+   * 新しいファイルをデフォルトコンテンツで作成
+   */
+  async writeDefault() {
+    const dirPath = this.pathSystem.dirname(this.filePath);
+    const dirName = this.pathSystem.basename(dirPath) || "\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA";
+    const defaultContent = [
+      `# ${dirName}`,
+      "",
+      `${dirName}\u306B\u95A2\u3059\u308B\u6982\u8981\u3092\u3053\u3053\u306B\u8A18\u8F09\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+    ].join("\n");
+    await this.fileSystem.writeFile(this.filePath, defaultContent);
+  }
+  /**
+   * ファイルを削除
+   */
+  async delete() {
+    return await this.fileSystem.deleteFile(this.filePath);
+  }
+  /**
+   * ファイルが存在するか確認
+   */
+  async exists() {
+    return this.fileSystem.exists(this.filePath);
+  }
+  async relations() {
+    const indexFile = await this.read();
+    if (indexFile instanceof Error) {
+      return [];
+    }
+    const schema = indexFile.content.frontMatter.value.schema;
+    if (!schema) {
+      return [];
+    }
+    const relationFields = Object.entries(schema).filter(([_key, field]) => {
+      return field.type === "relation" || field.type === "multi-relation";
+    });
+    return relationFields.map(([, field]) => {
+      if ((field.type === "relation" || field.type === "multi-relation") && field.path) {
+        return new DocFileRelationReference({
+          filePath: field.path,
+          fileSystem: this.fileSystem,
+          pathSystem: this.pathSystem
+        });
+      }
+      throw new Error("Unexpected field type or missing path");
+    });
+  }
+  async readRelations() {
+    const relations = await this.relations();
+    const files = [];
+    for (const relation of relations) {
+      const entity = await relation.read();
+      if (entity === null) continue;
+      files.push(entity);
+    }
+    return files;
+  }
+  /**
+   * ファイルのサイズを取得（バイト単位）
+   */
+  async size() {
+    return this.fileSystem.getFileSize(this.filePath);
+  }
+  /**
+   * ファイルの最終更新日時を取得
+   */
+  async lastModified() {
+    return this.fileSystem.getFileModifiedTime(this.filePath);
+  }
+  /**
+   * ファイルの作成日時を取得
+   */
+  async createdAt() {
+    return this.fileSystem.getFileCreatedTime(this.filePath);
+  }
+  /**
+   * ファイルをアーカイブに移動し、新しい参照を返す
+   */
+  async archive(archiveDirectoryName = "_") {
+    const dirPath = this.pathSystem.dirname(this.filePath);
+    const fileName = this.pathSystem.basename(this.filePath);
+    const archivePath = this.pathSystem.join(
+      dirPath,
+      archiveDirectoryName,
+      fileName
+    );
+    await this.fileSystem.moveFile(this.filePath, archivePath);
+    return new _DocFileIndexReference({
+      path: archivePath,
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem
+    });
+  }
+  /**
+   * ファイルをアーカイブから復元し、新しい参照を返す
+   */
+  async restore(archiveDirectoryName = "_") {
+    const dirPath = this.pathSystem.dirname(this.filePath);
+    const parentDirName = this.pathSystem.basename(dirPath);
+    if (parentDirName !== archiveDirectoryName) {
+      throw new Error(
+        `\u30D5\u30A1\u30A4\u30EB\u306F\u30A2\u30FC\u30AB\u30A4\u30D6\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306B\u3042\u308A\u307E\u305B\u3093: ${this.filePath}`
+      );
+    }
+    const fileName = this.pathSystem.basename(this.filePath);
+    const restorePath = this.pathSystem.join(
+      this.pathSystem.dirname(dirPath),
+      fileName
+    );
+    await this.fileSystem.moveFile(this.filePath, restorePath);
+    return new _DocFileIndexReference({
+      path: restorePath,
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem
+    });
+  }
+};
+
+// lib/doc-file-md-reference.ts
+var DocFileMdReference = class _DocFileMdReference {
+  constructor(props) {
+    this.props = props;
+    this.pathSystem = props.pathSystem;
+    Object.freeze(this);
+  }
+  pathSystem;
+  get fileSystem() {
+    return this.props.fileSystem;
+  }
+  get basePath() {
+    return this.fileSystem.getBasePath();
+  }
+  get path() {
+    return this.props.path;
+  }
+  get fullPath() {
+    return this.pathSystem.join(this.basePath, this.path);
+  }
+  get directoryPath() {
+    return this.pathSystem.dirname(this.path);
+  }
+  get archivedPath() {
+    return this.pathSystem.join(this.directoryPath, "_", this.nameWithExtension);
+  }
+  get name() {
+    return this.pathSystem.basename(this.path, ".md");
+  }
+  get nameWithExtension() {
+    return `${this.name}.md`;
+  }
+  directory() {
+    return new DocDirectoryReference({
+      archiveDirectoryName: "_",
+      indexFileName: "index.md",
+      fileSystem: this.fileSystem,
+      path: this.directoryPath,
+      pathSystem: this.pathSystem
+    });
+  }
+  async read() {
+    const content = await this.fileSystem.readFile(this.path);
+    const actualPath = this.path;
+    if (content === null) {
+      const content2 = await this.fileSystem.readFile(this.archivedPath);
+      if (content2 !== null) {
+        const contentValue2 = DocFileContentMdValue.fromMarkdown(content2);
+        const pathValue2 = DocFilePathValue.fromPathWithSystem(
+          actualPath,
+          this.pathSystem,
+          this.basePath
+        );
+        return new DocFileMdEntity({
+          type: "markdown",
+          content: contentValue2.value,
+          path: pathValue2.value,
+          isArchived: true
+        });
+      }
+    }
+    if (content === null) {
+      return new Error(`File not found at ${this.path} or in archive.`);
+    }
+    const contentValue = DocFileContentMdValue.fromMarkdown(content);
+    const pathValue = DocFilePathValue.fromPathWithSystem(
+      actualPath,
+      this.pathSystem,
+      this.basePath
+    );
+    const isInArchiveDir = this.path.includes("/_/") || this.path.startsWith("_/");
+    return new DocFileMdEntity({
+      type: "markdown",
+      content: contentValue.value,
+      path: pathValue.value,
+      isArchived: isInArchiveDir
+    });
+  }
+  /**
+   * ファイルの内容を読み込む
+   */
+  async readContent() {
+    const entity = await this.read();
+    if (entity instanceof Error) {
+      return entity;
+    }
+    return entity.value.content.body;
+  }
+  /**
+   * ファイルに内容を書き込む
+   */
+  async writeContent(content) {
+    return await this.fileSystem.writeFile(this.path, content);
+  }
+  /**
+   * Entityを書き込む
+   */
+  async write(entity) {
+    const content = entity.content.toText();
+    return await this.fileSystem.writeFile(this.path, content);
+  }
+  /**
+   * 新しいファイルをデフォルトコンテンツで作成
+   */
+  async writeDefault() {
+    const fileName = this.pathSystem.basename(this.path, ".md");
+    const defaultContent = [
+      `# ${fileName}`,
+      "",
+      "\u3053\u3053\u306B\u5185\u5BB9\u3092\u8A18\u8F09\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    ].join("\n");
+    return await this.fileSystem.writeFile(this.path, defaultContent);
+  }
+  /**
+   * ファイルを削除
+   */
+  async delete() {
+    return await this.fileSystem.deleteFile(this.path);
+  }
+  /**
+   * ファイルが存在するか確認（アーカイブも含む）
+   */
+  async exists() {
+    if (await this.fileSystem.exists(this.path)) {
+      return true;
+    }
+    const dirPath = this.pathSystem.dirname(this.path);
+    const fileName = this.pathSystem.basename(this.path);
+    const archivePath = this.pathSystem.join(dirPath, "_", fileName);
+    return this.fileSystem.exists(archivePath);
+  }
+  /**
+   * ファイルをコピー
+   */
+  async copyTo(destinationPath) {
+    await this.fileSystem.copyFile(this.path, destinationPath);
+  }
+  /**
+   * ファイルを移動
+   */
+  async moveTo(destinationPath) {
+    await this.fileSystem.moveFile(this.path, destinationPath);
+  }
+  /**
+   * ファイルのサイズを取得（バイト単位）
+   */
+  async size() {
+    return this.fileSystem.getFileSize(this.path);
+  }
+  /**
+   * ファイルの最終更新日時を取得
+   */
+  async lastModified() {
+    return this.fileSystem.getFileModifiedTime(this.path);
+  }
+  /**
+   * ファイルの作成日時を取得
+   */
+  async createdAt() {
+    return this.fileSystem.getFileCreatedTime(this.path);
+  }
+  /**
+   * ファイルをアーカイブに移動し、新しい参照を返す
+   */
+  async archive(archiveDirectoryName = "_") {
+    const dirPath = this.pathSystem.dirname(this.path);
+    const fileName = this.pathSystem.basename(this.path);
+    const archivePath = this.pathSystem.join(
+      dirPath,
+      archiveDirectoryName,
+      fileName
+    );
+    await this.moveTo(archivePath);
+    return new _DocFileMdReference({
+      path: archivePath,
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem
+    });
+  }
+  /**
+   * ファイルをアーカイブから復元し、新しい参照を返す
+   */
+  async restore(archiveDirectoryName = "_") {
+    const dirPath = this.pathSystem.dirname(this.path);
+    const parentDirName = this.pathSystem.basename(dirPath);
+    if (parentDirName !== archiveDirectoryName) {
+      throw new Error(
+        `\u30D5\u30A1\u30A4\u30EB\u306F\u30A2\u30FC\u30AB\u30A4\u30D6\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306B\u3042\u308A\u307E\u305B\u3093: ${this.path}`
+      );
+    }
+    const fileName = this.pathSystem.basename(this.path);
+    const restorePath = this.pathSystem.join(
+      this.pathSystem.dirname(dirPath),
+      fileName
+    );
+    await this.moveTo(restorePath);
+    return new _DocFileMdReference({
+      path: restorePath,
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem
+    });
+  }
+  /**
+   * スキーマに基づいてリレーションを取得する
+   */
+  async relation(key) {
+    const file = await this.read();
+    if (file instanceof Error) {
+      return file;
+    }
+    const relationValue = file.content.frontMatter.relation(key);
+    if (relationValue === null) {
+      return null;
+    }
+    const indexFile = await this.getDirectoryIndex();
+    if (!indexFile) {
+      return null;
+    }
+    const schemaData = indexFile.content.frontMatter.value.schema;
+    if (!schemaData || typeof schemaData !== "object" || Array.isArray(schemaData)) {
+      return null;
+    }
+    const schema = new DocSchemaValue(schemaData);
+    const field = schema.field(key);
+    if (!field || !("path" in field) || !field.path) {
+      return null;
+    }
+    const fullPath = this.pathSystem.join(field.path, `${relationValue}.md`);
+    return new _DocFileMdReference({
+      path: fullPath,
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem
+    });
+  }
+  /**
+   * 同じディレクトリのindex.mdを取得する
+   */
+  async getDirectoryIndex() {
+    const indexPath = this.pathSystem.join(this.directoryPath, "index.md");
+    const indexRef = new _DocFileMdReference({
+      path: indexPath,
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem
+    });
+    const indexFile = await indexRef.read();
+    if (indexFile instanceof Error) {
+      return null;
+    }
+    return indexFile;
+  }
+  /**
+   * 複数のリレーションを取得する
+   */
+  async relations(key) {
+    return this.multiRelation(key);
+  }
+  /**
+   * スキーマに基づいて複数のリレーションを取得する
+   */
+  async multiRelation(key) {
+    const file = await this.read();
+    if (file instanceof Error) {
+      return [];
+    }
+    const relationValues = file.content.frontMatter.multiRelation(key);
+    if (relationValues.length === 0) {
+      return [];
+    }
+    const indexFile = await this.getDirectoryIndex();
+    if (!indexFile) {
+      return [];
+    }
+    const schemaData = indexFile.content.frontMatter.value.schema;
+    if (!schemaData || typeof schemaData !== "object" || Array.isArray(schemaData)) {
+      return [];
+    }
+    const schema = new DocSchemaValue(schemaData);
+    const field = schema.field(key);
+    if (!field || !("path" in field) || !field.path) {
+      return [];
+    }
+    return relationValues.map((relationValue) => {
+      const fullPath = this.pathSystem.join(field.path, `${relationValue}.md`);
+      return new _DocFileMdReference({
+        path: fullPath,
+        fileSystem: this.fileSystem,
+        pathSystem: this.pathSystem
+      });
+    });
+  }
+};
+
+// lib/entities/doc-file-unknown-entity.ts
+var DocFileUnknownEntity = class _DocFileUnknownEntity {
+  constructor(value) {
+    this.value = value;
+    zDocFileUnknown.parse(value);
+    Object.freeze(this);
+  }
+  /**
+   * コンテンツ
+   */
+  get content() {
+    return this.value.content;
+  }
+  /**
+   * パス情報
+   */
+  get path() {
+    return this.value.path;
+  }
+  /**
+   * コンテンツを更新
+   */
+  withContent(content) {
+    return new _DocFileUnknownEntity({
+      ...this.value,
+      content
+    });
+  }
+  /**
+   * パスを更新
+   */
+  withPath(path) {
+    return new _DocFileUnknownEntity({
+      ...this.value,
+      path
+    });
+  }
+  toJson() {
+    return this.value;
+  }
+};
+
+// lib/doc-file-unknown-reference.ts
+var DocFileUnknownReference = class _DocFileUnknownReference {
+  constructor(props) {
+    this.props = props;
+    this.pathSystem = props.pathSystem;
+    Object.freeze(this);
+  }
+  pathSystem;
+  get fileSystem() {
+    return this.props.fileSystem;
+  }
+  get basePath() {
+    return this.fileSystem.getBasePath();
+  }
+  get path() {
+    return this.props.path;
+  }
+  get directoryPath() {
+    return this.pathSystem.dirname(this.path);
+  }
+  get fileFullPath() {
+    return this.pathSystem.join(this.basePath, this.path);
+  }
+  get durectoryPath() {
+    return this.pathSystem.dirname(this.path);
+  }
+  directory() {
+    return new DocDirectoryReference({
+      archiveDirectoryName: "_",
+      indexFileName: "index.md",
+      fileSystem: this.fileSystem,
+      path: this.directoryPath,
+      pathSystem: this.pathSystem
+    });
+  }
+  async read() {
+    const content = await this.fileSystem.readFile(this.path);
+    if (content === null) {
+      return new Error(`File not found at ${this.path}.`);
+    }
+    const isInArchiveDir = this.path.includes("/_/") || this.path.startsWith("_/");
+    if (this.path.endsWith(".md")) {
+      const contentValue = DocFileContentMdValue.fromMarkdown(content);
+      const pathValue2 = DocFilePathValue.fromPathWithSystem(
+        this.path,
+        this.pathSystem,
+        this.basePath
+      );
+      return new DocFileMdEntity({
+        type: "markdown",
+        content: contentValue.value,
+        path: pathValue2.value,
+        isArchived: isInArchiveDir
+      });
+    }
+    const pathValue = DocFilePathValue.fromPathWithSystem(
+      this.path,
+      this.pathSystem,
+      this.basePath
+    );
+    const extension = this.pathSystem.extname(this.path).substring(1);
+    return new DocFileUnknownEntity({
+      type: "unknown",
+      path: pathValue.value,
+      content,
+      extension,
+      isArchived: isInArchiveDir
+    });
+  }
+  /**
+   * ファイルの内容を読み込む
+   */
+  async readContent() {
+    const entity = await this.read();
+    if (entity instanceof Error) {
+      return entity;
+    }
+    if (typeof entity.value.content === "string") {
+      return entity.value.content;
+    }
+    return entity.value.content.body;
+  }
+  /**
+   * ファイルに内容を書き込む
+   */
+  async writeContent(content) {
+    await this.fileSystem.writeFile(this.path, content);
+  }
+  /**
+   * Entityを書き込む
+   */
+  async write(entity) {
+    await this.fileSystem.writeFile(this.path, entity.value.content);
+  }
+  /**
+   * 生のコンテンツを書き込む
+   */
+  async writeRaw(content) {
+    await this.fileSystem.writeFile(this.path, content);
+  }
+  /**
+   * ファイルを削除
+   */
+  async delete() {
+    return await this.fileSystem.deleteFile(this.path);
+  }
+  /**
+   * ファイルが存在するか確認
+   */
+  async exists() {
+    return this.fileSystem.exists(this.path);
+  }
+  /**
+   * ファイルをコピー
+   */
+  async copyTo(destinationPath) {
+    await this.fileSystem.copyFile(this.path, destinationPath);
+  }
+  /**
+   * ファイルを移動
+   */
+  async moveTo(destinationPath) {
+    await this.fileSystem.moveFile(this.path, destinationPath);
+  }
+  /**
+   * ファイルのサイズを取得（バイト単位）
+   */
+  async size() {
+    return this.fileSystem.getFileSize(this.path);
+  }
+  /**
+   * ファイルの最終更新日時を取得
+   */
+  async lastModified() {
+    return this.fileSystem.getFileModifiedTime(this.path);
+  }
+  /**
+   * ファイルの作成日時を取得
+   */
+  async createdAt() {
+    return this.fileSystem.getFileCreatedTime(this.path);
+  }
+  /**
+   * ファイルをアーカイブに移動し、新しい参照を返す
+   */
+  async archive(archiveDirectoryName = "_") {
+    const dirPath = this.pathSystem.dirname(this.path);
+    const fileName = this.pathSystem.basename(this.path);
+    const archivePath = this.pathSystem.join(
+      dirPath,
+      archiveDirectoryName,
+      fileName
+    );
+    await this.moveTo(archivePath);
+    return new _DocFileUnknownReference({
+      path: archivePath,
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem
+    });
+  }
+  /**
+   * ファイルをアーカイブから復元し、新しい参照を返す
+   */
+  async restore(archiveDirectoryName = "_") {
+    const dirPath = this.pathSystem.dirname(this.path);
+    const parentDirName = this.pathSystem.basename(dirPath);
+    if (parentDirName !== archiveDirectoryName) {
+      throw new Error(
+        `\u30D5\u30A1\u30A4\u30EB\u306F\u30A2\u30FC\u30AB\u30A4\u30D6\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306B\u3042\u308A\u307E\u305B\u3093: ${this.path}`
+      );
+    }
+    const fileName = this.pathSystem.basename(this.path);
+    const restorePath = this.pathSystem.join(
+      this.pathSystem.dirname(dirPath),
+      fileName
+    );
+    await this.moveTo(restorePath);
+    return new _DocFileUnknownReference({
+      path: restorePath,
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem
+    });
+  }
+};
+
+// lib/doc-directory-reference.ts
+var DocDirectoryReference = class _DocDirectoryReference {
+  constructor(props) {
+    this.props = props;
+    this.pathSystem = props.pathSystem;
+    Object.freeze(this);
+  }
+  pathSystem;
+  get fileSystem() {
+    return this.props.fileSystem;
+  }
+  get basePath() {
+    return this.fileSystem.getBasePath();
+  }
+  get relativePath() {
+    return this.props.path;
+  }
+  get absolutePath() {
+    return this.pathSystem.join(this.basePath, this.relativePath);
+  }
+  get indexFileName() {
+    return this.props.indexFileName;
+  }
+  get indexFilePath() {
+    return this.pathSystem.join(
+      this.basePath,
+      this.relativePath,
+      this.props.indexFileName
+    );
+  }
+  get archiveDirectoryName() {
+    return this.props.archiveDirectoryName;
+  }
+  async fileNames() {
+    const filePaths = await this.fileSystem.readDirectoryFilePaths(
+      this.relativePath
+    );
+    return filePaths.map((p) => this.pathSystem.basename(p)).filter((name) => name.includes("."));
+  }
+  async archivedFileNames() {
+    const archivePath = this.pathSystem.join(
+      this.relativePath,
+      this.archiveDirectoryName
+    );
+    const filePaths = await this.fileSystem.readDirectoryFilePaths(archivePath);
+    return filePaths.map((p) => this.pathSystem.basename(p)).filter((name) => name.includes("."));
+  }
+  async *filesGenerator() {
+    const fileNames = await this.fileNames();
+    for (const fileName of fileNames) {
+      if (fileName === "index.md") continue;
+      if (fileName.endsWith(".md")) {
+        yield new DocFileMdReference({
+          path: this.pathSystem.join(this.relativePath, fileName),
+          fileSystem: this.fileSystem,
+          pathSystem: this.pathSystem
+        });
+        continue;
+      }
+      yield new DocFileUnknownReference({
+        path: this.pathSystem.join(this.relativePath, fileName),
+        fileSystem: this.fileSystem,
+        pathSystem: this.pathSystem
+      });
+    }
+    const archivedFileNames = await this.archivedFileNames();
+    for (const fileName of archivedFileNames) {
+      if (fileName === "index.md") continue;
+      if (fileName.endsWith(".md")) {
+        yield new DocFileMdReference({
+          path: this.pathSystem.join(
+            this.relativePath,
+            this.archiveDirectoryName,
+            fileName
+          ),
+          fileSystem: this.fileSystem,
+          pathSystem: this.pathSystem
+        });
+        continue;
+      }
+      yield new DocFileUnknownReference({
+        path: this.pathSystem.join(
+          this.relativePath,
+          this.archiveDirectoryName,
+          fileName
+        ),
+        fileSystem: this.fileSystem,
+        pathSystem: this.pathSystem
+      });
+    }
+  }
+  async *mdFilesGenerator() {
+    const files = this.filesGenerator();
+    for await (const file of files) {
+      if (file instanceof DocFileMdReference) {
+        yield file;
+      }
+    }
+  }
+  async files() {
+    const files = [];
+    for await (const file of this.filesGenerator()) {
+      files.push(file);
+    }
+    return files;
+  }
+  async mdFiles() {
+    const files = [];
+    for await (const file of this.filesGenerator()) {
+      if (file instanceof DocFileUnknownReference) continue;
+      files.push(file);
+    }
+    return files;
+  }
+  file(fileName) {
+    const filePath = this.pathSystem.join(this.relativePath, fileName);
+    if (fileName.endsWith(".md")) {
+      return new DocFileMdReference({
+        path: filePath,
+        fileSystem: this.fileSystem,
+        pathSystem: this.pathSystem
+      });
+    }
+    return new DocFileUnknownReference({
+      path: filePath,
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem
+    });
+  }
+  mdFile(fileName) {
+    return new DocFileMdReference({
+      path: this.pathSystem.join(this.relativePath, fileName),
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem
+    });
+  }
+  async readFiles() {
+    const entities = [];
+    for await (const file of this.filesGenerator()) {
+      const entity = await file.read();
+      if (entity instanceof Error) continue;
+      entities.push(entity);
+    }
+    return entities;
+  }
+  async readMdFiles() {
+    const entities = [];
+    for await (const file of this.filesGenerator()) {
+      const entity = await file.read();
+      if (entity instanceof Error) continue;
+      if (entity instanceof DocFileUnknownEntity) continue;
+      entities.push(entity);
+    }
+    return entities;
+  }
+  async readUnknownFiles() {
+    const entities = [];
+    for await (const file of this.filesGenerator()) {
+      const entity = await file.read();
+      if (entity instanceof Error) continue;
+      if (entity instanceof DocFileMdEntity) continue;
+      entities.push(entity);
+    }
+    return entities;
+  }
+  /**
+   * サブディレクトリ名の一覧を取得
+   */
+  async directoryNames() {
+    const allFileNames = await this.fileSystem.readDirectoryFileNames(
+      this.relativePath
+    );
+    const directoryNames = [];
+    for (const fileName of allFileNames) {
+      if (fileName.startsWith(this.archiveDirectoryName)) continue;
+      const filePath = this.pathSystem.join(this.relativePath, fileName);
+      const isDirectory = await this.fileSystem.isDirectory(filePath);
+      if (isDirectory) {
+        directoryNames.push(fileName);
+      }
+    }
+    return directoryNames;
+  }
+  /**
+   * サブディレクトリの参照を取得
+   */
+  async directories() {
+    const directoryNames = await this.directoryNames();
+    return directoryNames.map((dirName) => {
+      const dirPath = this.pathSystem.join(this.relativePath, dirName);
+      return new _DocDirectoryReference({
+        path: dirPath,
+        indexFileName: this.indexFileName,
+        archiveDirectoryName: this.archiveDirectoryName,
+        fileSystem: this.fileSystem,
+        pathSystem: this.pathSystem
+      });
+    });
+  }
+  /**
+   * 単一のサブディレクトリ参照を取得
+   */
+  directory(directoryName) {
+    const dirPath = this.pathSystem.join(this.relativePath, directoryName);
+    return new _DocDirectoryReference({
+      path: dirPath,
+      indexFileName: this.indexFileName,
+      archiveDirectoryName: this.archiveDirectoryName,
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem
+    });
+  }
+  indexFile() {
+    return new DocFileIndexReference({
+      path: this.pathSystem.join(this.relativePath, this.indexFileName),
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem
+    });
+  }
+  async readIndexFile() {
+    const ref = this.indexFile();
+    return ref.read();
+  }
+  async writeFile(entity) {
+    const filePath = this.pathSystem.join(
+      this.relativePath,
+      entity.value.path.nameWithExtension
+    );
+    let content = null;
+    if (entity instanceof DocFileUnknownEntity) {
+      content = entity.value.content;
+    }
+    if (entity instanceof DocFileIndexEntity) {
+      content = entity.content.toText();
+    }
+    if (entity instanceof DocFileMdEntity) {
+      content = entity.content.toText();
+    }
+    if (content === null) {
+      return new Error("Entity content is undefined");
+    }
+    await this.fileSystem.writeFile(filePath, content);
+    return null;
+  }
+  async exists() {
+    return await this.fileSystem.exists(this.relativePath);
+  }
+  /**
+   * 一意なファイル名を生成する
+   */
+  async generateUniqueFileName(prefix = "document") {
+    const now = /* @__PURE__ */ new Date();
+    const timestamp = now.toISOString().slice(0, 19).replace(/[:-]/g, "");
+    let counter = 0;
+    let fileName;
+    do {
+      const suffix = counter > 0 ? `-${counter}` : "";
+      fileName = `${prefix}-${timestamp}${suffix}.md`;
+      counter++;
+    } while (await this.fileExists(fileName));
+    return fileName;
+  }
+  /**
+   * 指定されたファイル名のファイルが存在するかチェック
+   */
+  async fileExists(fileName) {
+    const filePath = this.pathSystem.join(this.relativePath, fileName);
+    return await this.fileSystem.exists(filePath);
+  }
+  /**
+   * 新しいMarkdownファイルを作成する
+   */
+  async createMdFile(fileName) {
+    const actualFileName = fileName || await this.generateUniqueFileName("document");
+    const mdFileName = actualFileName.endsWith(".md") ? actualFileName : `${actualFileName}.md`;
+    const filePath = this.pathSystem.join(this.relativePath, mdFileName);
+    const fileRef = new DocFileMdReference({
+      path: filePath,
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem
+    });
+    await fileRef.writeDefault();
+    return fileRef;
+  }
+};
+
+// lib/values/doc-tree-file-node-value.ts
+var DocTreeFileNodeValue = class _DocTreeFileNodeValue {
+  constructor(props) {
+    this.props = props;
+    Object.freeze(this);
+  }
+  get name() {
+    return this.props.name;
+  }
+  get path() {
+    return this.props.path;
+  }
+  get icon() {
+    return this.props.icon;
+  }
+  get title() {
+    return this.props.title;
+  }
+  get type() {
+    return "file";
+  }
+  /**
+   * プレーンオブジェクトに変換
+   */
+  toJson() {
+    return {
+      name: this.name,
+      path: this.path,
+      type: "file",
+      icon: this.icon,
+      title: this.title
+    };
+  }
+  /**
+   * プロパティから作成
+   */
+  static from(props) {
+    return new _DocTreeFileNodeValue(props);
+  }
+  /**
+   * JSONオブジェクトから作成
+   */
+  static fromJson(json) {
+    const parsed = zDocTreeFileNode.parse(json);
+    return new _DocTreeFileNodeValue({
+      name: parsed.name,
+      path: parsed.path,
+      icon: parsed.icon,
+      title: parsed.title
+    });
+  }
+};
+
+// lib/values/doc-tree-directory-node-value.ts
+var DocTreeDirectoryNodeValue = class _DocTreeDirectoryNodeValue {
+  constructor(props) {
+    this.props = props;
+    Object.freeze(this);
+    Object.freeze(this.props);
+    Object.freeze(this.props.children);
+  }
+  get name() {
+    return this.props.name;
+  }
+  get path() {
+    return this.props.path;
+  }
+  get icon() {
+    return this.props.icon;
+  }
+  get title() {
+    return this.props.title;
+  }
+  get children() {
+    return this.props.children;
+  }
+  get type() {
+    return "directory";
+  }
+  /**
+   * プレーンオブジェクトに変換
+   */
+  toJson() {
+    return {
+      name: this.name,
+      path: this.path,
+      type: "directory",
+      icon: this.icon,
+      title: this.title,
+      children: this.children.map((child) => child.toJson())
+    };
+  }
+  /**
+   * プロパティから作成
+   */
+  static from(props) {
+    return new _DocTreeDirectoryNodeValue(props);
+  }
+  /**
+   * JSONオブジェクトから作成
+   */
+  static fromJson(json) {
+    const parsed = zDocTreeDirectoryNode.parse(json);
+    return new _DocTreeDirectoryNodeValue({
+      name: parsed.name,
+      path: parsed.path,
+      icon: parsed.icon,
+      title: parsed.title,
+      children: parsed.children.map((child) => {
+        const parsedChild = zDocTreeNode.parse(child);
+        if (parsedChild.type === "file") {
+          return DocTreeFileNodeValue.fromJson(parsedChild);
+        }
+        return _DocTreeDirectoryNodeValue.fromJson(parsedChild);
+      })
+    });
+  }
+};
+
+// lib/doc-file-tree-system.ts
+var DocFileTreeSystem = class {
+  constructor(props) {
+    this.props = props;
+    Object.freeze(this);
+  }
+  /**
+   * ファイルツリーを再帰的に構築
+   */
+  async buildFileTree(directoryPath = "") {
+    const fileNames = await this.props.fileSystem.readDirectoryFileNames(directoryPath);
+    const results = [];
+    for (const fileName of fileNames) {
+      if (fileName.startsWith("_")) continue;
+      const filePath = directoryPath ? this.props.pathSystem.join(directoryPath, fileName) : fileName;
+      const isDirectory = await this.props.fileSystem.isDirectory(filePath);
+      if (!isDirectory) {
+        const fileNode = await this.createFileNode(fileName, filePath);
+        results.push(fileNode);
+        continue;
+      }
+      const directoryNode = await this.createDirectoryNode(fileName, filePath);
+      results.push(directoryNode);
+    }
+    return results;
+  }
+  /**
+   * ファイルノードを作成
+   */
+  async createFileNode(fileName, filePath) {
+    let title = fileName;
+    let icon = "";
+    if (fileName.endsWith(".md")) {
+      const mdFile = this.createMdFileReference(filePath);
+      if (await mdFile.exists()) {
+        const entity = await mdFile.read();
+        if (!(entity instanceof Error)) {
+          title = entity.value.content.title || fileName;
+        }
+      }
+      icon = "\u{1F4C4}";
+    } else {
+      icon = "\u{1F4C4}";
+    }
+    return DocTreeFileNodeValue.from({
+      name: fileName,
+      path: filePath,
+      icon,
+      title
+    });
+  }
+  /**
+   * ディレクトリノードを作成
+   */
+  async createDirectoryNode(fileName, filePath) {
+    let title = fileName;
+    let icon = "\u{1F4C1}";
+    const indexFile = this.createIndexFileReference(filePath);
+    if (await indexFile.exists()) {
+      const entity = await indexFile.read();
+      title = entity.value.content.title || fileName;
+      icon = entity.value.content.frontMatter.icon || "\u{1F4C1}";
+    }
+    const children = await this.buildFileTree(filePath);
+    return DocTreeDirectoryNodeValue.from({
+      name: fileName,
+      path: filePath,
+      icon,
+      title,
+      children
+    });
+  }
+  /**
+   * インデックスファイル参照を作成
+   */
+  createIndexFileReference(directoryPath) {
+    const indexPath = directoryPath === "" ? this.props.indexFileName : `${directoryPath}/${this.props.indexFileName}`;
+    return new DocFileIndexReference({
+      path: indexPath,
+      fileSystem: this.props.fileSystem,
+      pathSystem: this.props.pathSystem
+    });
+  }
+  /**
+   * MDファイル参照を作成
+   */
+  createMdFileReference(path) {
+    return new DocFileMdReference({
+      path,
+      fileSystem: this.props.fileSystem,
+      pathSystem: this.props.pathSystem
+    });
+  }
+  /**
+   * ディレクトリツリーを再帰的に構築（ディレクトリのみ）
+   */
+  async buildDirectoryTree(directoryPath = "") {
+    const fileNames = await this.props.fileSystem.readDirectoryFileNames(directoryPath);
+    const results = [];
+    for (const fileName of fileNames) {
+      if (fileName.startsWith("_")) continue;
+      const filePath = directoryPath ? this.props.pathSystem.join(directoryPath, fileName) : fileName;
+      const isDirectory = await this.props.fileSystem.isDirectory(filePath);
+      if (!isDirectory) continue;
+      const directoryNode = await this.createDirectoryNodeForTree(
+        fileName,
+        filePath
+      );
+      results.push(directoryNode);
+    }
+    return results;
+  }
+  /**
+   * ディレクトリツリー用のディレクトリノードを作成
+   */
+  async createDirectoryNodeForTree(fileName, filePath) {
+    let title = fileName;
+    let icon = "\u{1F4C1}";
+    const indexFile = this.createIndexFileReference(filePath);
+    if (await indexFile.exists()) {
+      const entity = await indexFile.read();
+      title = entity.value.content.title || fileName;
+      icon = entity.value.content.frontMatter.icon || "\u{1F4C1}";
+    }
+    const children = await this.buildDirectoryTree(filePath);
+    return DocTreeDirectoryNodeValue.from({
+      name: fileName,
+      path: filePath,
+      icon,
+      title,
+      children
+    });
+  }
+};
+
+// lib/doc-path-system.ts
+var DocPathSystem = class {
+  separator = "/";
+  /**
+   * パスを結合
+   */
+  join(...paths) {
+    const parts = [];
+    for (const path of paths) {
+      if (path === "") continue;
+      const segments = path.split(this.separator).filter(Boolean);
+      parts.push(...segments);
+    }
+    if (parts.length === 0) {
+      return ".";
+    }
+    const isAbsolute = paths[0]?.startsWith(this.separator);
+    const joined = parts.join(this.separator);
+    return isAbsolute ? `${this.separator}${joined}` : joined;
+  }
+  /**
+   * ファイル名を取得（拡張子付き）
+   */
+  basename(path, ext) {
+    const segments = path.split(this.separator);
+    const filename = segments[segments.length - 1] || "";
+    if (ext && filename.endsWith(ext)) {
+      return filename.slice(0, -ext.length);
+    }
+    return filename;
+  }
+  /**
+   * ディレクトリ名を取得
+   */
+  dirname(path) {
+    const segments = path.split(this.separator);
+    if (segments.length <= 1) {
+      return ".";
+    }
+    segments.pop();
+    const dir = segments.join(this.separator);
+    return dir || ".";
+  }
+  /**
+   * 拡張子を取得
+   */
+  extname(path) {
+    const basename = this.basename(path);
+    const lastDot = basename.lastIndexOf(".");
+    if (lastDot <= 0) {
+      return "";
+    }
+    return basename.slice(lastDot);
+  }
+  /**
+   * 相対パスを計算
+   */
+  relative(from, to) {
+    const fromSegments = from.split(this.separator).filter(Boolean);
+    const toSegments = to.split(this.separator).filter(Boolean);
+    let commonLength = 0;
+    for (let i = 0; i < Math.min(fromSegments.length, toSegments.length); i++) {
+      if (fromSegments[i] === toSegments[i]) {
+        commonLength++;
+      } else {
+        break;
+      }
+    }
+    const upCount = fromSegments.length - commonLength;
+    const upSegments = Array(upCount).fill("..");
+    const downSegments = toSegments.slice(commonLength);
+    const segments = [...upSegments, ...downSegments];
+    return segments.length > 0 ? segments.join(this.separator) : ".";
+  }
+  /**
+   * 絶対パスに変換
+   */
+  resolve(...paths) {
+    let resolved = "";
+    for (const path of paths) {
+      if (path.startsWith(this.separator)) {
+        resolved = path;
+      } else if (path !== "") {
+        resolved = resolved ? this.join(resolved, path) : path;
+      }
+    }
+    return resolved || ".";
+  }
+  /**
+   * パスを正規化
+   */
+  normalize(path) {
+    const isAbsolute = path.startsWith(this.separator);
+    const segments = path.split(this.separator).filter(Boolean);
+    const normalized = [];
+    for (const segment of segments) {
+      if (segment === "..") {
+        if (normalized.length > 0 && normalized[normalized.length - 1] !== "..") {
+          normalized.pop();
+        } else if (!isAbsolute) {
+          normalized.push("..");
+        }
+      } else if (segment !== ".") {
+        normalized.push(segment);
+      }
+    }
+    if (normalized.length === 0) {
+      return isAbsolute ? this.separator : ".";
+    }
+    const result = normalized.join(this.separator);
+    return isAbsolute ? `${this.separator}${result}` : result;
+  }
+  /**
+   * パスが絶対パスかどうか
+   */
+  isAbsolute(path) {
+    return path.startsWith(this.separator);
+  }
+  /**
+   * パスのセパレータ
+   */
+  get sep() {
+    return this.separator;
+  }
+};
+
+// lib/doc-client.ts
+var DocClient = class {
+  fileSystem;
+  pathSystem;
+  markdownSystem;
+  fileTreeSystem;
+  indexFileName;
+  archiveDirectoryName;
+  constructor(props) {
+    this.fileSystem = props.fileSystem;
+    this.pathSystem = props.pathSystem ?? new DocPathSystem();
+    this.markdownSystem = props.markdownSystem ?? new DocMarkdownSystem();
+    this.indexFileName = props.indexFileName ?? "index.md";
+    this.archiveDirectoryName = props.archiveDirectoryName ?? "_";
+    this.fileTreeSystem = props.fileTreeSystem ?? new DocFileTreeSystem({
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem,
+      indexFileName: this.indexFileName,
+      archiveDirectoryName: this.archiveDirectoryName
+    });
+  }
+  basePath() {
+    return this.fileSystem.getBasePath();
+  }
+  /**
+   * ファイル参照を取得
+   */
+  file(relativePath) {
+    if (relativePath.endsWith(".md")) {
+      return this.mdFile(relativePath);
+    }
+    return new DocFileUnknownReference({
+      path: relativePath,
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem
+    });
+  }
+  /**
+   * Markdownファイル参照を取得
+   */
+  mdFile(relativePath) {
+    return new DocFileMdReference({
+      path: relativePath,
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem
+    });
+  }
+  /**
+   * インデックスファイル参照を取得
+   */
+  indexFile(directoryPath) {
+    const indexPath = directoryPath === "" ? this.indexFileName : `${directoryPath}/${this.indexFileName}`;
+    return new DocFileIndexReference({
+      path: indexPath,
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem
+    });
+  }
+  /**
+   * ディレクトリ参照を取得
+   */
+  directory(relativePath) {
+    return new DocDirectoryReference({
+      path: relativePath,
+      indexFileName: this.indexFileName,
+      archiveDirectoryName: this.archiveDirectoryName,
+      fileSystem: this.fileSystem,
+      pathSystem: this.pathSystem
+    });
+  }
+  /**
+   * ファイルツリーを取得
+   */
+  async fileTree(directoryPath = "") {
+    const results = await this.fileTreeSystem.buildFileTree(directoryPath);
+    return results.map((node) => node.toJson());
+  }
+  /**
+   * ディレクトリツリーを取得（ディレクトリのみ）
+   */
+  async directoryTree(directoryPath = "") {
+    const results = await this.fileTreeSystem.buildDirectoryTree(directoryPath);
+    return results.map((node) => node.toJson());
+  }
+};
+
+// lib/doc-file-system.ts
+import fs from "fs/promises";
+var DocFileSystem = class {
+  basePath;
+  pathSystem;
+  constructor(props) {
+    this.basePath = props.basePath;
+    this.pathSystem = props.pathSystem;
+  }
+  /**
+   * 指定されたパスのファイルの内容を読み込む
+   */
+  async readFile(relativePath) {
+    const exists = await this.exists(relativePath);
+    if (!exists) return null;
+    const fullPath = this.pathSystem.join(this.basePath, relativePath);
+    try {
+      return await fs.readFile(fullPath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * 指定されたパスのファイルに内容を書き込む（必要に応じてディレクトリも作成）
+   */
+  async writeFile(relativePath, content) {
+    const fullPath = this.pathSystem.join(this.basePath, relativePath);
+    const dirPath = this.pathSystem.dirname(fullPath);
+    try {
+      await fs.mkdir(dirPath, { recursive: true });
+      await fs.writeFile(fullPath, content, "utf-8");
+    } catch (error) {
+      if (error instanceof Error) {
+        throw error;
+      }
+      throw new Error(`Failed to write file at ${fullPath}`);
+    }
+  }
+  /**
+   * 指定されたパスのファイルを削除
+   */
+  async deleteFile(relativePath) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      await fs.unlink(fullPath);
+      return null;
+    } catch (error) {
+      return new Error(`Failed to delete file at ${relativePath}: ${error}`);
+    }
+  }
+  /**
+   * 指定されたパスのファイル名を取得
+   */
+  readFileName(relativePath) {
+    return this.pathSystem.basename(relativePath);
+  }
+  /**
+   * 指定されたパスのファイル拡張子を取得
+   */
+  readFileExtension(relativePath) {
+    return this.pathSystem.extname(relativePath);
+  }
+  /**
+   * 指定されたパスのファイルが存在するディレクトリパスを取得
+   */
+  readFileDirectory(relativePath) {
+    return this.pathSystem.dirname(relativePath);
+  }
+  /**
+   * ディレクトリ内のエントリ一覧を取得
+   */
+  async readDirectoryFileNames(relativePath = "") {
+    const fullPath = this.pathSystem.join(this.basePath, relativePath);
+    try {
+      return await fs.readdir(fullPath);
+    } catch {
+      return [];
+    }
+  }
+  async readDirectoryFilePaths(relativePath) {
+    const fileNames = await this.readDirectoryFileNames(relativePath);
+    return fileNames.map(
+      (fileName) => this.pathSystem.join(relativePath, fileName)
+    );
+  }
+  /**
+   * 指定パスがディレクトリかチェック
+   */
+  async isDirectory(relativePath) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      const stats = await fs.stat(fullPath);
+      return stats.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 指定パスがファイルかチェック
+   */
+  async isFile(relativePath) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      const stats = await fs.stat(fullPath);
+      return stats.isFile();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * ファイルまたはディレクトリが存在するかチェック
+   */
+  async exists(relativePath) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      await fs.access(fullPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * ディレクトリが存在するかチェック
+   */
+  async directoryExists(relativePath) {
+    return this.isDirectory(relativePath);
+  }
+  /**
+   * ファイルが存在するかチェック
+   */
+  async fileExists(relativePath) {
+    return this.isFile(relativePath);
+  }
+  /**
+   * ベースパスを取得
+   */
+  getBasePath() {
+    return this.basePath;
+  }
+  /**
+   * 相対パスを絶対パスに変換
+   */
+  resolve(relativePath) {
+    return this.pathSystem.join(this.basePath, relativePath);
+  }
+  /**
+   * ディレクトリを作成する
+   */
+  async createDirectory(relativePath) {
+    const fullPath = this.pathSystem.join(this.basePath, relativePath);
+    await fs.mkdir(fullPath, { recursive: true });
+  }
+  /**
+   * ファイルのサイズを取得（バイト単位）
+   */
+  async getFileSize(relativePath) {
+    const fullPath = this.pathSystem.join(this.basePath, relativePath);
+    const stats = await fs.stat(fullPath);
+    return stats.size;
+  }
+  /**
+   * ディレクトリが存在しない場合は作成する
+   */
+  async ensureDirectoryExists(relativePath) {
+    if (!await this.exists(relativePath)) {
+      await this.createDirectory(relativePath);
+    }
+  }
+  /**
+   * ファイルをコピー
+   */
+  async copyFile(sourcePath, destinationPath) {
+    const sourceFullPath = this.pathSystem.join(this.basePath, sourcePath);
+    const destFullPath = this.pathSystem.join(this.basePath, destinationPath);
+    await fs.copyFile(sourceFullPath, destFullPath);
+  }
+  /**
+   * ファイルを移動
+   */
+  async moveFile(sourcePath, destinationPath) {
+    const sourceFullPath = this.pathSystem.join(this.basePath, sourcePath);
+    const destFullPath = this.pathSystem.join(this.basePath, destinationPath);
+    await fs.rename(sourceFullPath, destFullPath);
+  }
+  /**
+   * ファイルの最終更新日時を取得
+   */
+  async getFileModifiedTime(relativePath) {
+    const fullPath = this.pathSystem.join(this.basePath, relativePath);
+    const stats = await fs.stat(fullPath);
+    return stats.mtime;
+  }
+  /**
+   * ファイルの作成日時を取得
+   */
+  async getFileCreatedTime(relativePath) {
+    const fullPath = this.pathSystem.join(this.basePath, relativePath);
+    const stats = await fs.stat(fullPath);
+    return stats.birthtime;
+  }
+};
+
+// lib/values/doc-directory-path-value.ts
+var DocDirectoryPathValue = class _DocDirectoryPathValue {
+  constructor(value, pathSystem) {
+    this.value = value;
+    this.pathSystem = pathSystem;
+    Object.freeze(this);
+  }
+  pathSystem;
+  /**
+   * 相対ディレクトリパス
+   */
+  get path() {
+    return this.value.path;
+  }
+  /**
+   * ディレクトリ名
+   */
+  get name() {
+    return this.value.name;
+  }
+  /**
+   * 親ディレクトリパスを取得
+   */
+  get parent() {
+    if (this.path === "." || this.path === "") {
+      return null;
+    }
+    const parentPath = this.pathSystem.dirname(this.path);
+    const parentName = parentPath === "." ? "" : this.pathSystem.basename(parentPath);
+    return new _DocDirectoryPathValue(
+      {
+        path: parentPath,
+        name: parentName,
+        fullPath: this.pathSystem.dirname(this.fullPath)
+      },
+      this.pathSystem
+    );
+  }
+  /**
+   * 親ディレクトリパス
+   */
+  get parentPath() {
+    return this.pathSystem.dirname(this.path);
+  }
+  /**
+   * 深さ（ディレクトリの階層数）
+   */
+  get depth() {
+    if (this.path === "." || this.path === "") {
+      return 0;
+    }
+    return this.path.split(this.pathSystem.sep).filter(Boolean).length;
+  }
+  /**
+   * パスセグメント（ディレクトリの配列）
+   */
+  get segments() {
+    return this.path.split(this.pathSystem.sep).filter(Boolean);
+  }
+  /**
+   * ルートからの相対パス（先頭のスラッシュなし）
+   */
+  get normalizedPath() {
+    return this.path.replace(/^\/+/, "");
+  }
+  /**
+   * アーカイブディレクトリかどうか（ディレクトリ名が「_」の場合）
+   */
+  get isArchived() {
+    return this.name === "_";
+  }
+  /**
+   * 隠しディレクトリかどうか
+   */
+  get isHidden() {
+    return this.name.startsWith(".");
+  }
+  /**
+   * ルートディレクトリかどうか
+   */
+  get isRoot() {
+    return this.path === "." || this.path === "";
+  }
+  /**
+   * 絶対パス
+   */
+  get fullPath() {
+    return this.value.fullPath;
+  }
+  /**
+   * インデックスファイルのパスを取得
+   */
+  get indexFile() {
+    return DocFilePathValue.fromPathWithSystem(
+      this.pathSystem.join(this.path, "index.md"),
+      this.pathSystem,
+      this.pathSystem.dirname(this.fullPath)
+    );
+  }
+  /**
+   * ファイルパスを作成
+   */
+  file(fileName) {
+    return DocFilePathValue.fromPathWithSystem(
+      this.pathSystem.join(this.path, fileName),
+      this.pathSystem,
+      this.pathSystem.dirname(this.fullPath)
+    );
+  }
+  /**
+   * サブディレクトリのパスを作成
+   */
+  subdirectory(dirName) {
+    const subPath = this.pathSystem.join(this.path, dirName);
+    return new _DocDirectoryPathValue(
+      {
+        path: subPath,
+        name: dirName,
+        fullPath: this.pathSystem.join(this.fullPath, dirName)
+      },
+      this.pathSystem
+    );
+  }
+  /**
+   * 相対パスからインスタンスを生成（DI対応）
+   */
+  static fromPathWithSystem(dirPath, basePath, pathSystem) {
+    const name = dirPath === "." ? "" : pathSystem.basename(dirPath);
+    const fullPath = dirPath === "." ? basePath : pathSystem.join(basePath, dirPath);
+    return new _DocDirectoryPathValue(
+      {
+        path: dirPath,
+        name,
+        fullPath
+      },
+      pathSystem
+    );
+  }
+  /**
+   * JSON形式で出力
+   */
+  toJson() {
+    return this.value;
+  }
+  /**
+   * パスが等しいかどうか
+   */
+  equals(other) {
+    return this.path === other.path;
+  }
+  /**
+   * 指定されたディレクトリがこのディレクトリの子孫かどうか
+   */
+  contains(other) {
+    const relative = this.pathSystem.relative(this.path, other.path);
+    return !relative.startsWith("..") && relative !== "";
+  }
+};
+export {
+  DocClient,
+  DocContentMdValue,
+  DocDirectoryPathValue,
+  DocDirectoryReference,
+  DocFileContentIndexValue,
+  DocFileContentMdValue,
+  DocFileIndexEntity,
+  DocFileIndexReference,
+  DocFileMdEntity,
+  DocFileMdReference,
+  DocFilePathValue,
+  DocFileRelationReference,
+  DocFileSystem,
+  DocFileUnknownEntity,
+  DocFileUnknownReference,
+  DocFrontMatterIndexValue,
+  DocFrontMatterMdValue,
+  DocMarkdownSystem,
+  DocPathSystem,
+  DocRelationFileValue,
+  DocRelationValue,
+  DocSchemaFieldBooleanMultipleValue,
+  DocSchemaFieldBooleanSingleValue,
+  DocSchemaFieldFactory,
+  DocSchemaFieldNumberMultipleValue,
+  DocSchemaFieldNumberSingleValue,
+  DocSchemaFieldRelationMultipleValue,
+  DocSchemaFieldRelationSingleValue,
+  DocSchemaFieldSelectNumberMultipleValue,
+  DocSchemaFieldSelectNumberSingleValue,
+  DocSchemaFieldSelectTextMultipleValue,
+  DocSchemaFieldSelectTextSingleValue,
+  DocSchemaFieldTextMultipleValue,
+  DocSchemaFieldTextSingleValue,
+  DocSchemaValue,
+  DocTreeDirectoryNodeValue,
+  DocTreeFileNodeValue,
+  DocFileTreeSystem as FileTreeSystem,
+  zDocFile,
+  zDocFileContentIndex,
+  zDocFileContentMd,
+  zDocFileIndex,
+  zDocFileIndexFrontMatter,
+  zDocFileMd,
+  zDocFileMdFrontMatter,
+  zDocFilePath,
+  zDocFileUnknown,
+  zDocRelation,
+  zDocRelationField,
+  zDocRelationFile,
+  zDocSchema,
+  zDocSchemaField,
+  zDocSchemaFieldBoolean,
+  zDocSchemaFieldMultiBoolean,
+  zDocSchemaFieldMultiNumber,
+  zDocSchemaFieldMultiRelation,
+  zDocSchemaFieldMultiSelectNumber,
+  zDocSchemaFieldMultiSelectText,
+  zDocSchemaFieldMultiText,
+  zDocSchemaFieldNumber,
+  zDocSchemaFieldRelation,
+  zDocSchemaFieldSelectNumber,
+  zDocSchemaFieldSelectText,
+  zDocSchemaFieldText,
+  zDocSchemaFieldType,
+  zDocTreeDirectoryNode,
+  zDocTreeFileNode,
+  zDocTreeNode
+};