@fortemi/core 2026.7.11 → 2026.7.12

package/dist/aiwg-index-shard.js

@@ -0,0 +1,2195 @@
+import Ajv2020 from 'ajv/dist/2020.js';
+import { gzipSync, gunzipSync } from 'fflate';
+import { v5 } from 'uuid';
+
+// src/aiwg-index.ts
+var REQUIRED_RECORD_FIELDS = [
+  "schema_version",
+  "id",
+  "type",
+  "source",
+  "facets",
+  "tags",
+  "concepts",
+  "relationships",
+  "provenance",
+  "privacy",
+  "updated_at"
+];
+function hasString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isPlainRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isOptionalStringArray(value) {
+  return value === void 0 || Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isSupportedIndexSchemaVersion(value) {
+  return value === "aiwg.fortemi.index.export.v1" || value === "aiwg.fortemi.index.export.v2";
+}
+function isSupportedRecordSchemaVersion(value) {
+  return value === "aiwg.fortemi.index.record.v1" || value === "aiwg.fortemi.index.record.v2";
+}
+function validateOptionalRichMetadata(item, index, errors) {
+  if (item.skos_concepts !== void 0) {
+    if (!Array.isArray(item.skos_concepts)) {
+      errors.push("items[" + index + "].skos_concepts must be an array when present");
+    } else {
+      for (const [conceptIndex, concept] of item.skos_concepts.entries()) {
+        if (!isPlainRecord(concept)) {
+          errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "] must be an object");
+          continue;
+        }
+        if (!hasString(concept.id)) errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "].id is required");
+        if (!hasString(concept.prefLabel)) errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "].prefLabel is required");
+        if (!isOptionalStringArray(concept.altLabels)) errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "].altLabels must be a string array");
+        if (concept.metadata !== void 0 && !isPlainRecord(concept.metadata)) {
+          errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "].metadata must be an object");
+        }
+      }
+    }
+  }
+  if (item.skos_relations !== void 0) {
+    if (!Array.isArray(item.skos_relations)) {
+      errors.push("items[" + index + "].skos_relations must be an array when present");
+    } else {
+      for (const [relationIndex, relation] of item.skos_relations.entries()) {
+        if (!isPlainRecord(relation)) {
+          errors.push("items[" + index + "].skos_relations[" + relationIndex + "] must be an object");
+          continue;
+        }
+        if (!hasString(relation.type)) errors.push("items[" + index + "].skos_relations[" + relationIndex + "].type is required");
+        if (!hasString(relation.source_id)) errors.push("items[" + index + "].skos_relations[" + relationIndex + "].source_id is required");
+        if (!hasString(relation.target_id)) errors.push("items[" + index + "].skos_relations[" + relationIndex + "].target_id is required");
+        if (relation.metadata !== void 0 && !isPlainRecord(relation.metadata)) {
+          errors.push("items[" + index + "].skos_relations[" + relationIndex + "].metadata must be an object");
+        }
+      }
+    }
+  }
+  if (item.provenance_events !== void 0) {
+    if (!Array.isArray(item.provenance_events)) {
+      errors.push("items[" + index + "].provenance_events must be an array when present");
+    } else {
+      for (const [eventIndex, event] of item.provenance_events.entries()) {
+        if (!isPlainRecord(event)) {
+          errors.push("items[" + index + "].provenance_events[" + eventIndex + "] must be an object");
+          continue;
+        }
+        if (!hasString(event.activity)) errors.push("items[" + index + "].provenance_events[" + eventIndex + "].activity is required");
+        if (event.attributes !== void 0 && !isPlainRecord(event.attributes)) {
+          errors.push("items[" + index + "].provenance_events[" + eventIndex + "].attributes must be an object");
+        }
+      }
+    }
+  }
+  if (Array.isArray(item.relationships)) {
+    for (const [relationshipIndex, relationship] of item.relationships.entries()) {
+      if (!isPlainRecord(relationship)) {
+        errors.push("items[" + index + "].relationships[" + relationshipIndex + "] must be an object");
+        continue;
+      }
+      if (relationship.metadata !== void 0 && !isPlainRecord(relationship.metadata)) {
+        errors.push("items[" + index + "].relationships[" + relationshipIndex + "].metadata must be an object");
+      }
+      if (relationship.direction !== void 0 && relationship.direction !== "upstream" && relationship.direction !== "downstream" && relationship.direction !== "related") {
+        errors.push("items[" + index + "].relationships[" + relationshipIndex + "].direction must be upstream, downstream, or related");
+      }
+      if (relationship.target_path !== void 0 && typeof relationship.target_path !== "string") {
+        errors.push("items[" + index + "].relationships[" + relationshipIndex + "].target_path must be a string");
+      }
+    }
+  }
+  if (item.search !== void 0) {
+    if (!isPlainRecord(item.search)) {
+      errors.push("items[" + index + "].search must be an object");
+    } else {
+      if (!isOptionalStringArray(item.search.triggers)) errors.push("items[" + index + "].search.triggers must be a string array");
+      if (!isOptionalStringArray(item.search.aliases)) errors.push("items[" + index + "].search.aliases must be a string array");
+      if (!isOptionalStringArray(item.search.tags)) errors.push("items[" + index + "].search.tags must be a string array");
+      if (item.search.frontmatter !== void 0 && !isPlainRecord(item.search.frontmatter)) {
+        errors.push("items[" + index + "].search.frontmatter must be an object");
+      }
+    }
+  }
+  if (item.chunks !== void 0) {
+    if (!Array.isArray(item.chunks)) {
+      errors.push("items[" + index + "].chunks must be an array when present");
+    } else {
+      for (const [chunkIndex, chunk] of item.chunks.entries()) {
+        if (!isPlainRecord(chunk)) {
+          errors.push("items[" + index + "].chunks[" + chunkIndex + "] must be an object");
+          continue;
+        }
+        if (chunk.metadata !== void 0 && !isPlainRecord(chunk.metadata)) {
+          errors.push("items[" + index + "].chunks[" + chunkIndex + "].metadata must be an object");
+        }
+      }
+    }
+  }
+  if (item.embeddings !== void 0) {
+    if (!Array.isArray(item.embeddings)) {
+      errors.push("items[" + index + "].embeddings must be an array when present");
+    } else {
+      for (const [embeddingIndex, embedding] of item.embeddings.entries()) {
+        if (!isPlainRecord(embedding)) {
+          errors.push("items[" + index + "].embeddings[" + embeddingIndex + "] must be an object");
+          continue;
+        }
+        const vector = embedding.embedding ?? embedding.vector;
+        if (vector !== void 0 && (!Array.isArray(vector) || !vector.every((entry) => typeof entry === "number"))) {
+          errors.push("items[" + index + "].embeddings[" + embeddingIndex + "].embedding/vector must be a number array");
+        }
+        if (embedding.metadata !== void 0 && !isPlainRecord(embedding.metadata)) {
+          errors.push("items[" + index + "].embeddings[" + embeddingIndex + "].metadata must be an object");
+        }
+      }
+    }
+  }
+  if (item.compatibility !== void 0 && !isPlainRecord(item.compatibility)) {
+    errors.push("items[" + index + "].compatibility must be an object");
+  }
+}
+function isPrivacyClassification(value) {
+  return value === "private" || value === "sanitized" || value === "public";
+}
+function isProvenanceConfidence(value) {
+  return value === "source" || value === "candidate" || value === "reviewed" || value === "rejected";
+}
+function validateProvenanceItems(item, index, errors) {
+  if (!Array.isArray(item.provenance)) return;
+  for (const [provIndex, prov] of item.provenance.entries()) {
+    const at = "items[" + index + "].provenance[" + provIndex + "]";
+    if (!isPlainRecord(prov)) {
+      errors.push(at + " must be an object");
+      continue;
+    }
+    if (!hasString(prov.field)) errors.push(at + ".field is required");
+    if (!hasString(prov.source)) errors.push(at + ".source is required");
+    if (!hasString(prov.path)) errors.push(at + ".path is required");
+    if (!isProvenanceConfidence(prov.confidence)) errors.push(at + ".confidence must be one of source, candidate, reviewed, rejected");
+    if (!isPrivacyClassification(prov.privacy)) errors.push(at + ".privacy must be one of private, sanitized, public");
+  }
+}
+var V2_ONLY_RECORD_FIELDS = [
+  "search",
+  "chunks",
+  "embeddings",
+  "skos_concepts",
+  "skos_relations",
+  "provenance_events",
+  "compatibility"
+];
+var V2_ONLY_SOURCE_FIELDS = ["origin", "generated", "checksum", "updated_at"];
+var V2_ONLY_RELATIONSHIP_FIELDS = ["target_path", "direction", "metadata"];
+function forbidV2FieldsOnV1Record(item, index, errors) {
+  if (item.schema_version !== "aiwg.fortemi.index.record.v1") return;
+  const at = "items[" + index + "]";
+  const bag = item;
+  const v2msg = " is a v2-only field and must be absent on a record.v1 record";
+  for (const field of V2_ONLY_RECORD_FIELDS) {
+    if (bag[field] !== void 0) errors.push(at + "." + field + v2msg);
+  }
+  if (isPlainRecord(item.source)) {
+    const src = item.source;
+    for (const field of V2_ONLY_SOURCE_FIELDS) {
+      if (src[field] !== void 0) errors.push(at + ".source." + field + v2msg);
+    }
+  }
+  if (isPlainRecord(item.privacy) && item.privacy.locality !== void 0) {
+    errors.push(at + ".privacy.locality" + v2msg);
+  }
+  if (Array.isArray(item.relationships)) {
+    for (const [relIndex, rel] of item.relationships.entries()) {
+      if (!isPlainRecord(rel)) continue;
+      const relBag = rel;
+      for (const field of V2_ONLY_RELATIONSHIP_FIELDS) {
+        if (relBag[field] !== void 0) errors.push(at + ".relationships[" + relIndex + "]." + field + v2msg);
+      }
+    }
+  }
+}
+function validateAiwgFortemiIndexExport(value) {
+  const errors = [];
+  const counts = /* @__PURE__ */ Object.create(null);
+  const data = isPlainRecord(value) ? value : {};
+  if (!isPlainRecord(value)) errors.push("index export must be an object");
+  if (!isSupportedIndexSchemaVersion(data?.schema_version)) {
+    errors.push("schema_version must be aiwg.fortemi.index.export.v1 or aiwg.fortemi.index.export.v2");
+  }
+  if (!hasString(data?.generated_at)) errors.push("generated_at is required");
+  if (!hasString(data?.source?.repo)) errors.push("source.repo is required");
+  if (!hasString(data?.source?.privacy)) errors.push("source.privacy is required");
+  else if (!isPrivacyClassification(data?.source?.privacy)) {
+    errors.push("source.privacy must be one of private, sanitized, public");
+  }
+  if (!Array.isArray(data?.items)) errors.push("items must be an array");
+  if (data.compatibility !== void 0 && !isPlainRecord(data.compatibility)) {
+    errors.push("compatibility must be an object");
+  }
+  if (data?.schema_version === "aiwg.fortemi.index.export.v1") {
+    if (isPlainRecord(data.source) && data.source.graph !== void 0) {
+      errors.push("source.graph is a v2-only field and must be absent on an export.v1 export");
+    }
+    if (data.compatibility !== void 0) {
+      errors.push("compatibility is a v2-only field and must be absent on an export.v1 export");
+    }
+  }
+  const ids = /* @__PURE__ */ new Set();
+  let previousId = "";
+  const items = Array.isArray(data.items) ? data.items : [];
+  for (const [index, item] of items.entries()) {
+    if (!isPlainRecord(item)) {
+      errors.push("items[" + index + "] must be an object");
+      continue;
+    }
+    for (const field of REQUIRED_RECORD_FIELDS) {
+      if (!(field in item)) errors.push("items[" + index + "]." + field + " is required");
+    }
+    if (!isSupportedRecordSchemaVersion(item.schema_version)) {
+      errors.push("items[" + index + "].schema_version must be aiwg.fortemi.index.record.v1 or aiwg.fortemi.index.record.v2");
+    }
+    if (data.schema_version === "aiwg.fortemi.index.export.v1" && item.schema_version === "aiwg.fortemi.index.record.v2") {
+      errors.push("items[" + index + "].schema_version must match aiwg.fortemi.index.export.v1");
+    }
+    if (!hasString(item.id)) errors.push("items[" + index + "].id is required");
+    if (hasString(item.id) && ids.has(item.id)) errors.push("duplicate id: " + item.id);
+    if (hasString(item.id)) ids.add(item.id);
+    if (previousId && hasString(item.id) && previousId > item.id) {
+      errors.push("items must be sorted by id: " + previousId + " before " + item.id);
+    }
+    if (hasString(item.id)) previousId = item.id;
+    if (!hasString(item.type)) errors.push("items[" + index + "].type must be a non-empty string");
+    else counts[item.type] = (counts[item.type] ?? 0) + 1;
+    if (!hasString(item.source?.path)) errors.push("items[" + index + "].source.path is required");
+    if (!hasString(item.source?.repo_relative_path)) errors.push("items[" + index + "].source.repo_relative_path is required");
+    if (!hasString(item.source?.locator)) errors.push("items[" + index + "].source.locator is required");
+    if (typeof item.title !== "string" && typeof item.search?.title !== "string" && typeof item.search?.name !== "string") {
+      errors.push("items[" + index + "].title or search.title/search.name is required");
+    }
+    if (typeof item.text !== "string" && typeof item.search?.body !== "string" && typeof item.search?.summary !== "string") {
+      errors.push("items[" + index + "].text or search.body/search.summary is required");
+    }
+    if (!Array.isArray(item.tags)) errors.push("items[" + index + "].tags must be an array");
+    if (!Array.isArray(item.concepts)) errors.push("items[" + index + "].concepts must be an array");
+    if (!Array.isArray(item.relationships)) errors.push("items[" + index + "].relationships must be an array");
+    if (!Array.isArray(item.provenance) || item.provenance.length === 0) {
+      errors.push("items[" + index + "].provenance must be a non-empty array");
+    }
+    validateOptionalRichMetadata(item, index, errors);
+    validateProvenanceItems(item, index, errors);
+    forbidV2FieldsOnV1Record(item, index, errors);
+    if (!item.privacy || typeof item.privacy.pii !== "boolean" || !hasString(item.privacy.classification)) {
+      errors.push("items[" + index + "].privacy requires classification and pii");
+    } else if (!isPrivacyClassification(item.privacy.classification)) {
+      errors.push("items[" + index + "].privacy.classification must be one of private, sanitized, public");
+    }
+  }
+  return { valid: errors.length === 0, errors, counts };
+}
+
+// src/shard/checksum.ts
+async function sha256Hex(data) {
+  const buf = new ArrayBuffer(data.byteLength);
+  new Uint8Array(buf).set(data);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", buf);
+  const hashArray = new Uint8Array(hashBuffer);
+  return Array.from(hashArray).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function validateChecksums(checksums, files) {
+  const failures = [];
+  for (const [filename, expectedHash] of Object.entries(checksums)) {
+    const fileData = files.get(filename);
+    if (!fileData) {
+      failures.push(filename);
+      continue;
+    }
+    const actualHash = await sha256Hex(fileData);
+    if (actualHash !== expectedHash) {
+      failures.push(filename);
+    }
+  }
+  return { valid: failures.length === 0, failures };
+}
+
+// schemas/knowledge-shard/1.0.0/core-v1/manifest.schema.json
+var manifest_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schemas.fortemi.dev/knowledge-shard/1.0.0/core-v1/manifest.schema.json",
+  title: "Fortemi Knowledge Shard core-v1 manifest",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "version",
+    "profile",
+    "producer",
+    "format",
+    "created_at",
+    "components",
+    "counts",
+    "checksums",
+    "min_reader_version"
+  ],
+  properties: {
+    version: {
+      $ref: "#/$defs/strictSemVer"
+    },
+    profile: {
+      const: "core-v1"
+    },
+    producer: {
+      type: "object",
+      additionalProperties: false,
+      required: ["name", "version"],
+      properties: {
+        name: {
+          type: "string",
+          minLength: 1
+        },
+        version: {
+          type: "string",
+          minLength: 1
+        },
+        revision: {
+          type: "string",
+          minLength: 1
+        }
+      }
+    },
+    matric_version: {
+      type: "string",
+      minLength: 1,
+      deprecated: true
+    },
+    format: {
+      const: "matric-shard"
+    },
+    created_at: {
+      type: "string",
+      format: "date-time"
+    },
+    components: {
+      type: "array",
+      minItems: 1,
+      uniqueItems: true,
+      items: {
+        enum: ["notes", "collections", "tags", "templates", "links"]
+      }
+    },
+    counts: {
+      $ref: "#/$defs/counts"
+    },
+    checksums: {
+      type: "object",
+      propertyNames: {
+        enum: [
+          "notes.jsonl",
+          "collections.json",
+          "tags.json",
+          "templates.json",
+          "links.jsonl"
+        ]
+      },
+      additionalProperties: {
+        $ref: "#/$defs/sha256"
+      }
+    },
+    min_reader_version: {
+      $ref: "#/$defs/strictSemVer"
+    },
+    migrated_from: {
+      $ref: "#/$defs/strictSemVer"
+    },
+    migration_history: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: [
+          "from_version",
+          "to_version",
+          "migrated_at",
+          "migrated_by",
+          "changes"
+        ],
+        properties: {
+          from_version: {
+            $ref: "#/$defs/strictSemVer"
+          },
+          to_version: {
+            $ref: "#/$defs/strictSemVer"
+          },
+          migrated_at: {
+            type: "string",
+            format: "date-time"
+          },
+          migrated_by: {
+            type: "string",
+            minLength: 1
+          },
+          changes: {
+            type: "array",
+            minItems: 1,
+            items: {
+              type: "string",
+              minLength: 1
+            }
+          }
+        }
+      }
+    }
+  },
+  $defs: {
+    strictSemVer: {
+      type: "string",
+      pattern: "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)$"
+    },
+    sha256: {
+      type: "string",
+      pattern: "^[0-9a-f]{64}$"
+    },
+    count: {
+      type: "integer",
+      minimum: 0
+    },
+    counts: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "notes",
+        "collections",
+        "tags",
+        "templates",
+        "links",
+        "embedding_sets",
+        "embedding_set_members",
+        "embeddings",
+        "embedding_configs"
+      ],
+      properties: {
+        notes: {
+          $ref: "#/$defs/count"
+        },
+        collections: {
+          $ref: "#/$defs/count"
+        },
+        tags: {
+          $ref: "#/$defs/count"
+        },
+        templates: {
+          $ref: "#/$defs/count"
+        },
+        links: {
+          $ref: "#/$defs/count"
+        },
+        embedding_sets: {
+          const: 0
+        },
+        embedding_set_members: {
+          const: 0
+        },
+        embeddings: {
+          const: 0
+        },
+        embedding_configs: {
+          const: 0
+        }
+      }
+    }
+  }
+};
+
+// schemas/knowledge-shard/1.0.0/core-v1/note.schema.json
+var note_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schemas.fortemi.dev/knowledge-shard/1.0.0/core-v1/note.schema.json",
+  title: "Fortemi Knowledge Shard core-v1 note record",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "id",
+    "title",
+    "original_content",
+    "revised_content",
+    "metadata",
+    "format",
+    "source",
+    "starred",
+    "archived",
+    "collection_id",
+    "created_at",
+    "updated_at",
+    "tags",
+    "attachments"
+  ],
+  properties: {
+    id: {
+      $ref: "#/$defs/uuid"
+    },
+    title: {
+      type: ["string", "null"]
+    },
+    original_content: {
+      type: "string"
+    },
+    revised_content: {
+      type: "string"
+    },
+    metadata: true,
+    format: {
+      type: "string",
+      minLength: 1
+    },
+    source: {
+      type: "string",
+      minLength: 1
+    },
+    starred: {
+      type: "boolean"
+    },
+    archived: {
+      type: "boolean"
+    },
+    collection_id: {
+      oneOf: [
+        {
+          $ref: "#/$defs/uuid"
+        },
+        {
+          type: "null"
+        }
+      ]
+    },
+    created_at: {
+      $ref: "#/$defs/dateTime"
+    },
+    updated_at: {
+      $ref: "#/$defs/dateTime"
+    },
+    tags: {
+      type: "array",
+      uniqueItems: true,
+      items: {
+        type: "string",
+        minLength: 1
+      }
+    },
+    attachments: {
+      type: "array",
+      items: {
+        $ref: "#/$defs/attachmentProjection"
+      }
+    }
+  },
+  $defs: {
+    uuid: {
+      type: "string",
+      format: "uuid"
+    },
+    dateTime: {
+      type: "string",
+      format: "date-time"
+    },
+    sha256: {
+      type: "string",
+      pattern: "^blake3:[0-9a-f]{64}$"
+    },
+    attachmentProjection: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "extracted_text",
+        "extraction_status",
+        "reason",
+        "attachment"
+      ],
+      properties: {
+        extracted_text: {
+          type: ["string", "null"]
+        },
+        extraction_status: {
+          enum: ["extracted", "pending", "failed", "blocked", "deferred"]
+        },
+        reason: {
+          enum: [
+            null,
+            "extraction_pending",
+            "extractor_failed",
+            "quarantined",
+            "large_binary",
+            "unsupported_mime",
+            "no_extracted_text"
+          ]
+        },
+        attachment: {
+          type: "object",
+          additionalProperties: false,
+          required: ["id", "path", "mime", "checksum", "bytes"],
+          properties: {
+            id: {
+              $ref: "#/$defs/uuid"
+            },
+            path: {
+              type: "string",
+              minLength: 1
+            },
+            mime: {
+              type: "string",
+              minLength: 1
+            },
+            checksum: {
+              $ref: "#/$defs/sha256"
+            },
+            bytes: {
+              type: "integer",
+              minimum: 0
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// schemas/knowledge-shard/1.0.0/core-v1/collection.schema.json
+var collection_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schemas.fortemi.dev/knowledge-shard/1.0.0/core-v1/collection.schema.json",
+  title: "Fortemi Knowledge Shard core-v1 collection record",
+  type: "object",
+  additionalProperties: false,
+  required: ["id", "name", "description", "parent_id", "created_at", "note_count"],
+  properties: {
+    id: {
+      $ref: "#/$defs/uuid"
+    },
+    name: {
+      type: "string",
+      minLength: 1
+    },
+    description: {
+      type: ["string", "null"]
+    },
+    parent_id: {
+      oneOf: [
+        {
+          $ref: "#/$defs/uuid"
+        },
+        {
+          type: "null"
+        }
+      ]
+    },
+    created_at: {
+      type: "string",
+      format: "date-time"
+    },
+    note_count: {
+      type: "integer",
+      minimum: 0
+    }
+  },
+  $defs: {
+    uuid: {
+      type: "string",
+      format: "uuid"
+    }
+  }
+};
+
+// schemas/knowledge-shard/1.0.0/core-v1/tag.schema.json
+var tag_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schemas.fortemi.dev/knowledge-shard/1.0.0/core-v1/tag.schema.json",
+  title: "Fortemi Knowledge Shard core-v1 tag record",
+  type: "object",
+  additionalProperties: false,
+  required: ["name", "created_at"],
+  properties: {
+    name: {
+      type: "string",
+      minLength: 1
+    },
+    created_at: {
+      type: "string",
+      format: "date-time"
+    }
+  }
+};
+
+// schemas/knowledge-shard/1.0.0/core-v1/template.schema.json
+var template_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schemas.fortemi.dev/knowledge-shard/1.0.0/core-v1/template.schema.json",
+  title: "Fortemi Knowledge Shard core-v1 template record",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "id",
+    "name",
+    "description",
+    "content",
+    "format",
+    "default_tags",
+    "collection_id",
+    "created_at",
+    "updated_at"
+  ],
+  properties: {
+    id: {
+      $ref: "#/$defs/uuid"
+    },
+    name: {
+      type: "string",
+      minLength: 1
+    },
+    description: {
+      type: ["string", "null"]
+    },
+    content: {
+      type: "string"
+    },
+    format: {
+      type: "string",
+      minLength: 1
+    },
+    default_tags: {
+      type: "array",
+      uniqueItems: true,
+      items: {
+        type: "string",
+        minLength: 1
+      }
+    },
+    collection_id: {
+      oneOf: [
+        {
+          $ref: "#/$defs/uuid"
+        },
+        {
+          type: "null"
+        }
+      ]
+    },
+    created_at: {
+      type: "string",
+      format: "date-time"
+    },
+    updated_at: {
+      type: "string",
+      format: "date-time"
+    }
+  },
+  $defs: {
+    uuid: {
+      type: "string",
+      format: "uuid"
+    }
+  }
+};
+
+// schemas/knowledge-shard/1.0.0/core-v1/link.schema.json
+var link_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schemas.fortemi.dev/knowledge-shard/1.0.0/core-v1/link.schema.json",
+  title: "Fortemi Knowledge Shard core-v1 link record",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "id",
+    "from_note_id",
+    "to_note_id",
+    "to_url",
+    "kind",
+    "score",
+    "created_at",
+    "metadata"
+  ],
+  properties: {
+    id: {
+      $ref: "#/$defs/uuid"
+    },
+    from_note_id: {
+      $ref: "#/$defs/uuid"
+    },
+    to_note_id: {
+      oneOf: [
+        {
+          $ref: "#/$defs/uuid"
+        },
+        {
+          type: "null"
+        }
+      ]
+    },
+    to_url: {
+      type: ["string", "null"],
+      format: "uri"
+    },
+    kind: {
+      type: "string",
+      minLength: 1
+    },
+    score: {
+      type: "number"
+    },
+    created_at: {
+      type: "string",
+      format: "date-time"
+    },
+    metadata: true
+  },
+  oneOf: [
+    {
+      properties: {
+        to_note_id: {
+          $ref: "#/$defs/uuid"
+        },
+        to_url: {
+          type: "null"
+        }
+      }
+    },
+    {
+      properties: {
+        to_note_id: {
+          type: "null"
+        },
+        to_url: {
+          type: "string",
+          format: "uri"
+        }
+      }
+    }
+  ],
+  $defs: {
+    uuid: {
+      type: "string",
+      format: "uuid"
+    }
+  }
+};
+
+// schemas/knowledge-shard/1.1.0/core-v1/manifest.schema.json
+var manifest_schema_default2 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schemas.fortemi.dev/knowledge-shard/1.1.0/core-v1/manifest.schema.json",
+  title: "Fortemi Knowledge Shard core-v1 manifest",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "version",
+    "profile",
+    "producer",
+    "format",
+    "created_at",
+    "components",
+    "counts",
+    "checksums",
+    "min_reader_version"
+  ],
+  properties: {
+    version: {
+      const: "1.1.0"
+    },
+    profile: {
+      const: "core-v1"
+    },
+    producer: {
+      type: "object",
+      additionalProperties: false,
+      required: ["name", "version"],
+      properties: {
+        name: {
+          type: "string",
+          minLength: 1
+        },
+        version: {
+          type: "string",
+          minLength: 1
+        },
+        revision: {
+          type: "string",
+          minLength: 1
+        }
+      }
+    },
+    matric_version: {
+      type: "string",
+      minLength: 1,
+      deprecated: true
+    },
+    format: {
+      const: "matric-shard"
+    },
+    created_at: {
+      type: "string",
+      format: "date-time"
+    },
+    components: {
+      type: "array",
+      minItems: 1,
+      uniqueItems: true,
+      items: {
+        enum: ["notes", "collections", "tags", "templates", "links"]
+      }
+    },
+    counts: {
+      $ref: "#/$defs/counts"
+    },
+    checksums: {
+      type: "object",
+      propertyNames: {
+        enum: [
+          "notes.jsonl",
+          "collections.json",
+          "tags.json",
+          "templates.json",
+          "links.jsonl"
+        ]
+      },
+      additionalProperties: {
+        $ref: "#/$defs/sha256"
+      }
+    },
+    min_reader_version: {
+      const: "1.1.0"
+    },
+    migrated_from: {
+      $ref: "#/$defs/strictSemVer"
+    },
+    migration_history: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: [
+          "from_version",
+          "to_version",
+          "migrated_at",
+          "migrated_by",
+          "changes"
+        ],
+        properties: {
+          from_version: {
+            $ref: "#/$defs/strictSemVer"
+          },
+          to_version: {
+            $ref: "#/$defs/strictSemVer"
+          },
+          migrated_at: {
+            type: "string",
+            format: "date-time"
+          },
+          migrated_by: {
+            type: "string",
+            minLength: 1
+          },
+          changes: {
+            type: "array",
+            minItems: 1,
+            items: {
+              type: "string",
+              minLength: 1
+            }
+          }
+        }
+      }
+    }
+  },
+  $defs: {
+    strictSemVer: {
+      type: "string",
+      pattern: "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)$"
+    },
+    sha256: {
+      type: "string",
+      pattern: "^[0-9a-f]{64}$"
+    },
+    count: {
+      type: "integer",
+      minimum: 0
+    },
+    counts: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "notes",
+        "collections",
+        "tags",
+        "templates",
+        "links",
+        "embedding_sets",
+        "embedding_set_members",
+        "embeddings",
+        "embedding_configs"
+      ],
+      properties: {
+        notes: {
+          $ref: "#/$defs/count"
+        },
+        collections: {
+          $ref: "#/$defs/count"
+        },
+        tags: {
+          $ref: "#/$defs/count"
+        },
+        templates: {
+          $ref: "#/$defs/count"
+        },
+        links: {
+          $ref: "#/$defs/count"
+        },
+        embedding_sets: {
+          const: 0
+        },
+        embedding_set_members: {
+          const: 0
+        },
+        embeddings: {
+          const: 0
+        },
+        embedding_configs: {
+          const: 0
+        }
+      }
+    }
+  }
+};
+
+// schemas/knowledge-shard/1.2.0/core-v1/manifest.schema.json
+var manifest_schema_default5 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schemas.fortemi.dev/knowledge-shard/1.2.0/core-v1/manifest.schema.json",
+  title: "Fortemi Knowledge Shard core-v1 manifest",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "version",
+    "profile",
+    "producer",
+    "format",
+    "created_at",
+    "components",
+    "counts",
+    "checksums",
+    "min_reader_version"
+  ],
+  properties: {
+    version: {
+      const: "1.2.0"
+    },
+    profile: {
+      const: "core-v1"
+    },
+    producer: {
+      type: "object",
+      additionalProperties: false,
+      required: ["name", "version"],
+      properties: {
+        name: {
+          type: "string",
+          minLength: 1
+        },
+        version: {
+          type: "string",
+          minLength: 1
+        },
+        revision: {
+          type: "string",
+          minLength: 1
+        }
+      }
+    },
+    matric_version: {
+      type: "string",
+      minLength: 1,
+      deprecated: true
+    },
+    format: {
+      const: "matric-shard"
+    },
+    created_at: {
+      type: "string",
+      format: "date-time"
+    },
+    components: {
+      type: "array",
+      minItems: 1,
+      uniqueItems: true,
+      items: {
+        enum: ["notes", "collections", "tags", "templates", "links"]
+      }
+    },
+    counts: {
+      $ref: "#/$defs/counts"
+    },
+    checksums: {
+      type: "object",
+      propertyNames: {
+        enum: [
+          "notes.jsonl",
+          "collections.json",
+          "tags.json",
+          "templates.json",
+          "links.jsonl"
+        ]
+      },
+      additionalProperties: {
+        $ref: "#/$defs/sha256"
+      }
+    },
+    min_reader_version: {
+      const: "1.2.0"
+    },
+    migrated_from: {
+      $ref: "#/$defs/strictSemVer"
+    },
+    migration_history: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: [
+          "from_version",
+          "to_version",
+          "migrated_at",
+          "migrated_by",
+          "changes"
+        ],
+        properties: {
+          from_version: {
+            $ref: "#/$defs/strictSemVer"
+          },
+          to_version: {
+            $ref: "#/$defs/strictSemVer"
+          },
+          migrated_at: {
+            type: "string",
+            format: "date-time"
+          },
+          migrated_by: {
+            type: "string",
+            minLength: 1
+          },
+          changes: {
+            type: "array",
+            minItems: 1,
+            items: {
+              type: "string",
+              minLength: 1
+            }
+          }
+        }
+      }
+    }
+  },
+  $defs: {
+    strictSemVer: {
+      type: "string",
+      pattern: "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)$"
+    },
+    sha256: {
+      type: "string",
+      pattern: "^[0-9a-f]{64}$"
+    },
+    count: {
+      type: "integer",
+      minimum: 0
+    },
+    counts: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "notes",
+        "collections",
+        "tags",
+        "templates",
+        "links",
+        "embedding_sets",
+        "embedding_set_members",
+        "embeddings",
+        "embedding_configs"
+      ],
+      properties: {
+        notes: {
+          $ref: "#/$defs/count"
+        },
+        collections: {
+          $ref: "#/$defs/count"
+        },
+        tags: {
+          $ref: "#/$defs/count"
+        },
+        templates: {
+          $ref: "#/$defs/count"
+        },
+        links: {
+          $ref: "#/$defs/count"
+        },
+        embedding_sets: {
+          const: 0
+        },
+        embedding_set_members: {
+          const: 0
+        },
+        embeddings: {
+          const: 0
+        },
+        embedding_configs: {
+          const: 0
+        }
+      }
+    }
+  }
+};
+
+// schemas/knowledge-shard/1.2.0/core-v1/note.schema.json
+var note_schema_default2 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schemas.fortemi.dev/knowledge-shard/1.2.0/core-v1/note.schema.json",
+  title: "Fortemi Knowledge Shard core-v1 note record",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "id",
+    "title",
+    "original_content",
+    "revised_content",
+    "metadata",
+    "format",
+    "source",
+    "starred",
+    "archived",
+    "collection_id",
+    "created_at",
+    "updated_at",
+    "tags",
+    "attachments"
+  ],
+  properties: {
+    id: {
+      $ref: "#/$defs/uuid"
+    },
+    title: {
+      type: ["string", "null"]
+    },
+    original_content: {
+      type: "string"
+    },
+    revised_content: {
+      type: "string"
+    },
+    metadata: true,
+    format: {
+      type: "string",
+      minLength: 1
+    },
+    source: {
+      type: "string",
+      minLength: 1
+    },
+    starred: {
+      type: "boolean"
+    },
+    archived: {
+      type: "boolean"
+    },
+    collection_id: {
+      oneOf: [
+        {
+          $ref: "#/$defs/uuid"
+        },
+        {
+          type: "null"
+        }
+      ]
+    },
+    created_at: {
+      $ref: "#/$defs/dateTime"
+    },
+    updated_at: {
+      $ref: "#/$defs/dateTime"
+    },
+    deleted_at: {
+      oneOf: [
+        {
+          $ref: "#/$defs/dateTime"
+        },
+        {
+          type: "null"
+        }
+      ],
+      default: null
+    },
+    tags: {
+      type: "array",
+      uniqueItems: true,
+      items: {
+        type: "string",
+        minLength: 1
+      }
+    },
+    attachments: {
+      type: "array",
+      items: {
+        $ref: "#/$defs/attachmentProjection"
+      }
+    }
+  },
+  $defs: {
+    uuid: {
+      type: "string",
+      format: "uuid"
+    },
+    dateTime: {
+      type: "string",
+      format: "date-time"
+    },
+    sha256: {
+      type: "string",
+      pattern: "^blake3:[0-9a-f]{64}$"
+    },
+    attachmentProjection: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "extracted_text",
+        "extraction_status",
+        "reason",
+        "attachment"
+      ],
+      properties: {
+        extracted_text: {
+          type: ["string", "null"]
+        },
+        extraction_status: {
+          enum: ["extracted", "pending", "failed", "blocked", "deferred"]
+        },
+        reason: {
+          enum: [
+            null,
+            "extraction_pending",
+            "extractor_failed",
+            "quarantined",
+            "large_binary",
+            "unsupported_mime",
+            "no_extracted_text"
+          ]
+        },
+        attachment: {
+          type: "object",
+          additionalProperties: false,
+          required: ["id", "path", "mime", "checksum", "bytes"],
+          properties: {
+            id: {
+              $ref: "#/$defs/uuid"
+            },
+            path: {
+              type: "string",
+              minLength: 1
+            },
+            mime: {
+              type: "string",
+              minLength: 1
+            },
+            checksum: {
+              $ref: "#/$defs/sha256"
+            },
+            bytes: {
+              type: "integer",
+              minimum: 0
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// schemas/knowledge-shard/1.2.0/core-v1/collection.schema.json
+var collection_schema_default2 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schemas.fortemi.dev/knowledge-shard/1.2.0/core-v1/collection.schema.json",
+  title: "Fortemi Knowledge Shard core-v1 collection record",
+  type: "object",
+  additionalProperties: false,
+  required: ["id", "name", "description", "parent_id", "created_at", "note_count"],
+  properties: {
+    id: {
+      $ref: "#/$defs/uuid"
+    },
+    name: {
+      type: "string",
+      minLength: 1
+    },
+    description: {
+      type: ["string", "null"]
+    },
+    parent_id: {
+      oneOf: [
+        {
+          $ref: "#/$defs/uuid"
+        },
+        {
+          type: "null"
+        }
+      ]
+    },
+    created_at: {
+      type: "string",
+      format: "date-time"
+    },
+    note_count: {
+      type: "integer",
+      minimum: 0
+    }
+  },
+  $defs: {
+    uuid: {
+      type: "string",
+      format: "uuid"
+    }
+  }
+};
+
+// schemas/knowledge-shard/1.2.0/core-v1/tag.schema.json
+var tag_schema_default2 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schemas.fortemi.dev/knowledge-shard/1.2.0/core-v1/tag.schema.json",
+  title: "Fortemi Knowledge Shard core-v1 tag record",
+  type: "object",
+  additionalProperties: false,
+  required: ["name", "created_at"],
+  properties: {
+    name: {
+      type: "string",
+      minLength: 1
+    },
+    created_at: {
+      type: "string",
+      format: "date-time"
+    }
+  }
+};
+
+// schemas/knowledge-shard/1.2.0/core-v1/template.schema.json
+var template_schema_default2 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schemas.fortemi.dev/knowledge-shard/1.2.0/core-v1/template.schema.json",
+  title: "Fortemi Knowledge Shard core-v1 template record",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "id",
+    "name",
+    "description",
+    "content",
+    "format",
+    "default_tags",
+    "collection_id",
+    "created_at",
+    "updated_at"
+  ],
+  properties: {
+    id: {
+      $ref: "#/$defs/uuid"
+    },
+    name: {
+      type: "string",
+      minLength: 1
+    },
+    description: {
+      type: ["string", "null"]
+    },
+    content: {
+      type: "string"
+    },
+    format: {
+      type: "string",
+      minLength: 1
+    },
+    default_tags: {
+      type: "array",
+      uniqueItems: true,
+      items: {
+        type: "string",
+        minLength: 1
+      }
+    },
+    collection_id: {
+      oneOf: [
+        {
+          $ref: "#/$defs/uuid"
+        },
+        {
+          type: "null"
+        }
+      ]
+    },
+    created_at: {
+      type: "string",
+      format: "date-time"
+    },
+    updated_at: {
+      type: "string",
+      format: "date-time"
+    }
+  },
+  $defs: {
+    uuid: {
+      type: "string",
+      format: "uuid"
+    }
+  }
+};
+
+// schemas/knowledge-shard/1.2.0/core-v1/link.schema.json
+var link_schema_default2 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schemas.fortemi.dev/knowledge-shard/1.2.0/core-v1/link.schema.json",
+  title: "Fortemi Knowledge Shard core-v1 link record",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "id",
+    "from_note_id",
+    "to_note_id",
+    "to_url",
+    "kind",
+    "score",
+    "created_at",
+    "metadata"
+  ],
+  properties: {
+    id: {
+      $ref: "#/$defs/uuid"
+    },
+    from_note_id: {
+      $ref: "#/$defs/uuid"
+    },
+    to_note_id: {
+      oneOf: [
+        {
+          $ref: "#/$defs/uuid"
+        },
+        {
+          type: "null"
+        }
+      ]
+    },
+    to_url: {
+      type: ["string", "null"],
+      format: "uri"
+    },
+    kind: {
+      type: "string",
+      minLength: 1
+    },
+    score: {
+      type: "number"
+    },
+    created_at: {
+      type: "string",
+      format: "date-time"
+    },
+    metadata: true
+  },
+  oneOf: [
+    {
+      properties: {
+        to_note_id: {
+          $ref: "#/$defs/uuid"
+        },
+        to_url: {
+          type: "null"
+        }
+      }
+    },
+    {
+      properties: {
+        to_note_id: {
+          type: "null"
+        },
+        to_url: {
+          type: "string",
+          format: "uri"
+        }
+      }
+    }
+  ],
+  $defs: {
+    uuid: {
+      type: "string",
+      format: "uuid"
+    }
+  }
+};
+var BLOCK_SIZE = 512;
+var USTAR_MAGIC = "ustar\x0000";
+function writeString(buf, offset, str, len) {
+  for (let i = 0; i < Math.min(str.length, len); i++) {
+    buf[offset + i] = str.charCodeAt(i);
+  }
+}
+function writeOctal(buf, offset, value, len) {
+  const str = value.toString(8).padStart(len - 1, "0");
+  writeString(buf, offset, str, len - 1);
+}
+function computeHeaderChecksum(header) {
+  let sum = 0;
+  for (let i = 0; i < BLOCK_SIZE; i++) {
+    sum += i >= 148 && i < 156 ? 32 : header[i];
+  }
+  return sum;
+}
+function createTarHeader(filename, size) {
+  const header = new Uint8Array(BLOCK_SIZE);
+  writeString(header, 0, filename, 100);
+  writeOctal(header, 100, 420, 8);
+  writeOctal(header, 108, 0, 8);
+  writeOctal(header, 116, 0, 8);
+  writeOctal(header, 124, size, 12);
+  writeOctal(header, 136, 0, 12);
+  header[156] = 48;
+  writeString(header, 257, USTAR_MAGIC, 8);
+  const checksum = computeHeaderChecksum(header);
+  const csStr = checksum.toString(8).padStart(6, "0");
+  writeString(header, 148, csStr, 6);
+  header[154] = 0;
+  header[155] = 32;
+  return header;
+}
+function encodeTar(files) {
+  const blocks = [];
+  for (const [filename, data] of files) {
+    blocks.push(createTarHeader(filename, data.byteLength));
+    blocks.push(data);
+    const remainder = data.byteLength % BLOCK_SIZE;
+    if (remainder > 0) {
+      blocks.push(new Uint8Array(BLOCK_SIZE - remainder));
+    }
+  }
+  blocks.push(new Uint8Array(BLOCK_SIZE * 2));
+  let totalLen = 0;
+  for (const b of blocks) totalLen += b.byteLength;
+  const result = new Uint8Array(totalLen);
+  let offset = 0;
+  for (const b of blocks) {
+    result.set(b, offset);
+    offset += b.byteLength;
+  }
+  return result;
+}
+function readString(buf, offset, len) {
+  let end = offset;
+  const limit = offset + len;
+  while (end < limit && buf[end] !== 0) end++;
+  return String.fromCharCode(...buf.slice(offset, end));
+}
+function readOctal(buf, offset, len) {
+  const str = readString(buf, offset, len).trim();
+  return str.length > 0 ? parseInt(str, 8) : 0;
+}
+function isZeroBlock(buf, offset) {
+  for (let i = 0; i < BLOCK_SIZE; i++) {
+    if (buf[offset + i] !== 0) return false;
+  }
+  return true;
+}
+function decodeTar(tarData) {
+  const files = /* @__PURE__ */ new Map();
+  let offset = 0;
+  while (offset + BLOCK_SIZE <= tarData.byteLength) {
+    if (isZeroBlock(tarData, offset)) break;
+    const name = readString(tarData, offset, 100);
+    const size = readOctal(tarData, offset + 124, 12);
+    const typeflag = tarData[offset + 156];
+    offset += BLOCK_SIZE;
+    if (typeflag === 48 || typeflag === 0) {
+      files.set(name, tarData.slice(offset, offset + size));
+    }
+    const dataBlocks = Math.ceil(size / BLOCK_SIZE);
+    offset += dataBlocks * BLOCK_SIZE;
+  }
+  return files;
+}
+function packTarGz(files, opts) {
+  const tarData = encodeTar(files);
+  const cap = DEFAULT_MAX_DECOMPRESSED_BYTES;
+  if (tarData.byteLength > cap) {
+    throw new Error(
+      "Refusing to create archive: uncompressed size " + tarData.byteLength + " exceeds cap " + cap + " bytes"
+    );
+  }
+  return gzipSync(tarData, { mtime: 0 });
+}
+var DEFAULT_MAX_DECOMPRESSED_BYTES = 256 * 1024 * 1024;
+function unpackTarGz(data, opts) {
+  const cap = DEFAULT_MAX_DECOMPRESSED_BYTES;
+  if (data.byteLength < 18) {
+    throw new Error("Invalid gzip archive: too short");
+  }
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const declaredSize = view.getUint32(data.byteLength - 4, true);
+  if (declaredSize > cap) {
+    throw new Error(
+      "Refusing to decompress archive: declared size " + declaredSize + " exceeds cap " + cap + " bytes"
+    );
+  }
+  const tarData = gunzipSync(data);
+  if (tarData.byteLength > cap) {
+    throw new Error(
+      "Refusing to decompress archive: decompressed size " + tarData.byteLength + " exceeds cap " + cap + " bytes"
+    );
+  }
+  return decodeTar(tarData);
+}
+
+// src/shard/types.ts
+var CURRENT_SHARD_VERSION = "1.2.0";
+var SHARD_FORMAT = "matric-shard";
+
+// src/shard/schema-validator.ts
+var decoder = new TextDecoder();
+var CORE_V1_COMPONENT_FILES = {
+  notes: { file: "notes.jsonl", encoding: "jsonl" },
+  collections: { file: "collections.json", encoding: "json-array" },
+  tags: { file: "tags.json", encoding: "json-array" },
+  templates: { file: "templates.json", encoding: "json-array" },
+  links: { file: "links.jsonl", encoding: "jsonl" }
+};
+var CORE_V1_SCHEMAS = {
+  "1.0.0": {
+    manifest: manifest_schema_default,
+    notes: note_schema_default,
+    collections: collection_schema_default,
+    tags: tag_schema_default,
+    templates: template_schema_default,
+    links: link_schema_default
+  },
+  "1.1.0": {
+    manifest: manifest_schema_default2,
+    notes: note_schema_default2,
+    collections: collection_schema_default2,
+    tags: tag_schema_default2,
+    templates: template_schema_default2,
+    links: link_schema_default2
+  },
+  "1.2.0": {
+    manifest: manifest_schema_default5,
+    notes: note_schema_default2,
+    collections: collection_schema_default2,
+    tags: tag_schema_default2,
+    templates: template_schema_default2,
+    links: link_schema_default2
+  }
+};
+var coreAjvInstance;
+var coreValidators = /* @__PURE__ */ new Map();
+function addCanonicalFormats(ajv) {
+  ajv.addFormat("uuid", /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+  ajv.addFormat("date-time", {
+    type: "string",
+    validate: (value) => /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(value) && !Number.isNaN(Date.parse(value))
+  });
+  ajv.addFormat("uri", {
+    type: "string",
+    validate: (value) => {
+      try {
+        return Boolean(new URL(value).protocol);
+      } catch {
+        return false;
+      }
+    }
+  });
+}
+function getCoreAjv() {
+  if (!coreAjvInstance) {
+    coreAjvInstance = new Ajv2020({
+      allErrors: true,
+      strict: true,
+      validateFormats: true
+    });
+    addCanonicalFormats(coreAjvInstance);
+    const registered = /* @__PURE__ */ new Set();
+    for (const bundle of Object.values(CORE_V1_SCHEMAS)) {
+      for (const schema of Object.values(bundle)) {
+        if (!registered.has(schema.$id)) {
+          coreAjvInstance.addSchema(schema);
+          registered.add(schema.$id);
+        }
+      }
+    }
+  }
+  return coreAjvInstance;
+}
+function coreSchemaVersion(value) {
+  return value === "1.0.0" || value === "1.1.0" || value === "1.2.0" ? value : void 0;
+}
+function coreValidatorFor(name, version = CURRENT_SHARD_VERSION) {
+  const key = `${version}:${name}`;
+  const cached = coreValidators.get(key);
+  if (cached) return cached;
+  const schema = CORE_V1_SCHEMAS[version][name];
+  const validator = getCoreAjv().getSchema(schema.$id) ?? getCoreAjv().compile(schema);
+  coreValidators.set(key, validator);
+  return validator;
+}
+function formatErrors(errors) {
+  return (errors ?? []).map((error) => {
+    const path = error.instancePath || "(root)";
+    return `${path} ${error.message ?? "is invalid"}`;
+  });
+}
+function parseJsonArray(bytes, path) {
+  if (!bytes) return { records: [], errors: [] };
+  try {
+    const value = JSON.parse(decoder.decode(bytes));
+    if (!Array.isArray(value)) return { records: [], errors: [`${path} must be a JSON array`] };
+    return { records: value, errors: [] };
+  } catch {
+    return { records: [], errors: [`${path} failed to parse as JSON`] };
+  }
+}
+function parseJsonl(bytes, path) {
+  if (!bytes) return { records: [], errors: [] };
+  const text = decoder.decode(bytes).trim();
+  if (!text) return { records: [], errors: [] };
+  const records = [];
+  const errors = [];
+  for (const [index, line] of text.split("\n").entries()) {
+    try {
+      records.push(JSON.parse(line));
+    } catch {
+      errors.push(`${path}:${index + 1} failed to parse as JSON`);
+    }
+  }
+  return { records, errors };
+}
+function unpackShardFiles(input) {
+  if (input instanceof Map) return input;
+  return unpackTarGz(input instanceof ArrayBuffer ? new Uint8Array(input) : input);
+}
+function parseRecords(bytes, path, encoding) {
+  return encoding === "json-array" ? parseJsonArray(bytes, path) : parseJsonl(bytes, path);
+}
+function coreReferenceErrors(records) {
+  const errors = [];
+  const notes = records.get("notes");
+  const collections = records.get("collections");
+  const tags = records.get("tags");
+  const templates = records.get("templates");
+  const links = records.get("links");
+  const noteIds = new Set(notes.map((record) => record.id));
+  const collectionIds = new Set(collections.map((record) => record.id));
+  const tagNames = new Set(tags.map((record) => record.name));
+  for (const [index, collection] of collections.entries()) {
+    if (collection.parent_id !== null && !collectionIds.has(collection.parent_id)) {
+      errors.push(`collections.json[${index}] parent_id does not reference a declared collection`);
+    }
+  }
+  const collectionById = new Map(collections.map((collection) => [collection.id, collection]));
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visitCollection = (collection) => {
+    if (visited.has(collection.id)) return;
+    if (visiting.has(collection.id)) {
+      errors.push(`collection hierarchy contains a cycle at ${String(collection.id)}`);
+      return;
+    }
+    visiting.add(collection.id);
+    const parent = collection.parent_id === null ? void 0 : collectionById.get(collection.parent_id);
+    if (parent) visitCollection(parent);
+    visiting.delete(collection.id);
+    visited.add(collection.id);
+  };
+  for (const collection of collections) visitCollection(collection);
+  for (const [index, note] of notes.entries()) {
+    if (note.collection_id !== null && !collectionIds.has(note.collection_id)) {
+      errors.push(`notes.jsonl[${index}] collection_id does not reference a declared collection`);
+    }
+    for (const tag of note.tags) {
+      if (!tagNames.has(tag)) {
+        errors.push(`notes.jsonl[${index}] tag does not reference a declared tag`);
+      }
+    }
+  }
+  for (const [index, template] of templates.entries()) {
+    if (template.collection_id !== null && !collectionIds.has(template.collection_id)) {
+      errors.push(`templates.json[${index}] collection_id does not reference a declared collection`);
+    }
+    for (const tag of template.default_tags) {
+      if (!tagNames.has(tag)) {
+        errors.push(`templates.json[${index}] default tag does not reference a declared tag`);
+      }
+    }
+  }
+  for (const [index, link] of links.entries()) {
+    if (!noteIds.has(link.from_note_id)) {
+      errors.push(`links.jsonl[${index}] from_note_id does not reference a declared note`);
+    }
+    if (link.to_note_id !== null && !noteIds.has(link.to_note_id)) {
+      errors.push(`links.jsonl[${index}] to_note_id does not reference a declared note`);
+    }
+  }
+  return errors;
+}
+function validateCoreV1Structure(files, manifest) {
+  const errors = [];
+  const schemaVersion = coreSchemaVersion(manifest.version);
+  if (!schemaVersion) {
+    return ["manifest.json uses an unsupported canonical core-v1 schema version"];
+  }
+  const manifestValidator = coreValidatorFor("manifest", schemaVersion);
+  if (!manifestValidator(manifest)) {
+    return formatErrors(manifestValidator.errors).map((error) => `manifest.json ${error}`);
+  }
+  const components = manifest.components;
+  const expectedFiles = new Set(components.map((component) => CORE_V1_COMPONENT_FILES[component].file));
+  for (const filename of expectedFiles) {
+    if (!files.has(filename)) errors.push(`${filename} is declared but missing`);
+    if (!(filename in manifest.checksums)) errors.push(`${filename} is missing its declared checksum`);
+  }
+  for (const filename of Object.keys(manifest.checksums)) {
+    if (!expectedFiles.has(filename)) {
+      errors.push(`manifest checksum references undeclared file ${filename}`);
+    }
+  }
+  for (const filename of files.keys()) {
+    if (filename !== "manifest.json" && !expectedFiles.has(filename)) {
+      errors.push(`archive contains undeclared file ${filename}`);
+    }
+  }
+  const records = /* @__PURE__ */ new Map();
+  for (const component of components) {
+    const spec = CORE_V1_COMPONENT_FILES[component];
+    const parsed = parseRecords(files.get(spec.file), spec.file, spec.encoding);
+    errors.push(...parsed.errors);
+    const validator = coreValidatorFor(component, schemaVersion);
+    for (const [index, record] of parsed.records.entries()) {
+      if (!validator(record)) {
+        errors.push(
+          ...formatErrors(validator.errors).map((error) => `${spec.file}[${index}] ${error}`)
+        );
+      }
+    }
+    const expectedCount = manifest.counts[component];
+    if (expectedCount !== parsed.records.length) {
+      errors.push(
+        `${spec.file} count mismatch: manifest=${String(expectedCount)} actual=${parsed.records.length}`
+      );
+    }
+    records.set(component, parsed.records);
+  }
+  for (const component of Object.keys(CORE_V1_COMPONENT_FILES)) {
+    if (!records.has(component)) records.set(component, []);
+  }
+  if (errors.length === 0) errors.push(...coreReferenceErrors(records));
+  return errors;
+}
+async function validateCoreV1ShardArchive(input) {
+  let files;
+  try {
+    files = unpackShardFiles(input);
+  } catch {
+    return { valid: false, errors: ["archive failed to unpack"] };
+  }
+  const manifestBytes = files.get("manifest.json");
+  if (!manifestBytes) return { valid: false, errors: ["manifest.json is missing"] };
+  let manifest;
+  try {
+    manifest = JSON.parse(decoder.decode(manifestBytes));
+  } catch {
+    return { valid: false, errors: ["manifest.json failed to parse as JSON"] };
+  }
+  const errors = validateCoreV1Structure(files, manifest);
+  if (errors.length > 0) return { valid: false, errors };
+  const checksumResult = await validateChecksums(manifest.checksums, files);
+  if (!checksumResult.valid) {
+    errors.push(...checksumResult.failures.map((filename) => `${filename} checksum mismatch`));
+  }
+  return { valid: errors.length === 0, errors };
+}
+var AIWG_SHARD_UUID_NAMESPACE = "7ab5d1f8-29d2-5e35-9e2f-3a45de171a9e";
+var shardEncoder = new TextEncoder();
+var shardDecoder = new TextDecoder();
+function aiwgShardUuid(kind, id) {
+  return v5(`${kind}:${id}`, AIWG_SHARD_UUID_NAMESPACE);
+}
+function aiwgShardTimestamp(value, fallback) {
+  if (!value || Number.isNaN(Date.parse(value))) return fallback;
+  return new Date(value).toISOString();
+}
+function aiwgRecordTitle(record) {
+  return record.title ?? record.search?.title ?? record.search?.name ?? record.id;
+}
+function aiwgRecordContent(record) {
+  if (record.text) return record.text;
+  if (record.search?.body) return record.search.body;
+  const chunks = record.chunks?.map((chunk) => chunk.text ?? chunk.body ?? chunk.summary ?? "").filter(Boolean);
+  if (chunks?.length) return chunks.join("\n\n");
+  return record.search?.summary ?? "";
+}
+function aiwgShardMetadata(index, record) {
+  return {
+    aiwg_fortemi_index: {
+      envelope: {
+        schema_version: index.schema_version,
+        generated_at: index.generated_at,
+        source: index.source,
+        ...index.compatibility ? { compatibility: index.compatibility } : {}
+      },
+      record
+    }
+  };
+}
+function encodeJsonLines(values) {
+  return shardEncoder.encode(values.map((value) => JSON.stringify(value)).join("\n"));
+}
+async function aiwgFortemiIndexToKnowledgeShard(index, options = {}) {
+  if (options.includeNativeRichComponents) {
+    throw new Error(
+      "Native AIWG rich components require the complete full-v1 inventory; use core-v1 metadata preservation until full-v1 conversion is available"
+    );
+  }
+  const validation = validateAiwgFortemiIndexExport(index);
+  if (!validation.valid) {
+    throw new Error(`Invalid AIWG Fortemi index export:
+${validation.errors.join("\n")}`);
+  }
+  if (index.schema_version !== "aiwg.fortemi.index.export.v2") {
+    throw new Error("Knowledge Shard conversion requires aiwg.fortemi.index.export.v2");
+  }
+  const createdAt = aiwgShardTimestamp(options.createdAt ?? index.generated_at, (/* @__PURE__ */ new Date()).toISOString());
+  const noteIds = new Map(index.items.map((record) => [record.id, aiwgShardUuid("record", record.id)]));
+  const notes = index.items.map((record) => {
+    const content = aiwgRecordContent(record);
+    return {
+      id: noteIds.get(record.id),
+      title: aiwgRecordTitle(record),
+      original_content: content,
+      revised_content: content,
+      metadata: aiwgShardMetadata(index, record),
+      collection_id: null,
+      attachments: [],
+      format: "markdown",
+      source: "aiwg-index",
+      starred: false,
+      archived: false,
+      tags: [...new Set(record.tags)].sort(),
+      created_at: aiwgShardTimestamp(record.source.updated_at ?? record.updated_at, createdAt),
+      updated_at: aiwgShardTimestamp(record.updated_at, createdAt),
+      deleted_at: null
+    };
+  });
+  const links = [];
+  for (const record of index.items) {
+    for (const [position, relationship] of record.relationships.entries()) {
+      const targetNoteId = noteIds.get(relationship.target_id) ?? null;
+      links.push({
+        id: aiwgShardUuid(
+          "relationship",
+          `${record.id}\0${position}\0${relationship.type}\0${relationship.target_id}`
+        ),
+        from_note_id: noteIds.get(record.id),
+        to_note_id: targetNoteId,
+        to_url: targetNoteId ? null : `aiwg://record/${encodeURIComponent(relationship.target_id)}`,
+        kind: relationship.type,
+        score: relationship.confidence ?? 1,
+        created_at: aiwgShardTimestamp(record.updated_at, createdAt),
+        metadata: {
+          aiwg_fortemi_index: {
+            source_record_id: record.id,
+            target_record_id: relationship.target_id,
+            relationship
+          }
+        }
+      });
+    }
+  }
+  const files = /* @__PURE__ */ new Map();
+  const components = ["notes", "tags"];
+  const counts = {
+    notes: notes.length,
+    tags: [...new Set(notes.flatMap((note) => note.tags))].length
+  };
+  files.set("notes.jsonl", encodeJsonLines(notes));
+  files.set("tags.json", shardEncoder.encode(JSON.stringify(
+    [...new Set(notes.flatMap((note) => note.tags))].sort().map((name) => ({ name, created_at: createdAt }))
+  )));
+  const addComponent = (component, filename, values, jsonLines = true) => {
+    if (values.length === 0) return;
+    components.push(component);
+    counts[component] = values.length;
+    files.set(filename, jsonLines ? encodeJsonLines(values) : shardEncoder.encode(JSON.stringify(values)));
+  };
+  addComponent("links", "links.jsonl", links);
+  const checksums = {};
+  for (const [filename, bytes] of files) checksums[filename] = await sha256Hex(bytes);
+  const manifest = {
+    version: CURRENT_SHARD_VERSION,
+    profile: "core-v1",
+    producer: {
+      name: "fortemi-core-aiwg-index",
+      version: options.matricVersion ?? "fortemi-core"
+    },
+    format: SHARD_FORMAT,
+    created_at: createdAt,
+    components,
+    counts: {
+      notes: 0,
+      collections: 0,
+      tags: 0,
+      templates: 0,
+      links: 0,
+      embedding_sets: 0,
+      embedding_set_members: 0,
+      embeddings: 0,
+      embedding_configs: 0,
+      ...counts
+    },
+    checksums,
+    min_reader_version: CURRENT_SHARD_VERSION
+  };
+  files.set("manifest.json", shardEncoder.encode(JSON.stringify(manifest, null, 2)));
+  const contractValidation = await validateCoreV1ShardArchive(files);
+  if (!contractValidation.valid) {
+    throw new Error(
+      `Generated AIWG core-v1 shard failed canonical validation: ${contractValidation.errors.join("; ")}`
+    );
+  }
+  return packTarGz(files);
+}
+function aiwgFortemiIndexFromKnowledgeShard(bytes) {
+  const files = unpackTarGz(bytes);
+  const noteBytes = files.get("notes.jsonl");
+  const notes = (noteBytes ? shardDecoder.decode(noteBytes) : "").split("\n").filter(Boolean).map((line) => JSON.parse(line));
+  if (notes.length === 0) throw new Error("Knowledge Shard contains no AIWG index notes");
+  let envelope;
+  const items = [];
+  for (const note of notes) {
+    const metadata = note.metadata?.aiwg_fortemi_index;
+    if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+      throw new Error(`Knowledge Shard note ${note.id} has no AIWG index metadata`);
+    }
+    const value = metadata;
+    envelope ??= value.envelope;
+    items.push(value.record);
+  }
+  const restored = {
+    ...envelope,
+    items: items.sort((left, right) => left.id.localeCompare(right.id))
+  };
+  const validation = validateAiwgFortemiIndexExport(restored);
+  if (!validation.valid) {
+    throw new Error(`Knowledge Shard contains invalid AIWG index metadata:
+${validation.errors.join("\n")}`);
+  }
+  return restored;
+}
+
+export { aiwgFortemiIndexFromKnowledgeShard, aiwgFortemiIndexToKnowledgeShard };
+//# sourceMappingURL=aiwg-index-shard.js.map
+//# sourceMappingURL=aiwg-index-shard.js.map