@takuhon/core 0.1.0

package/dist/index.js

@@ -0,0 +1,919 @@
+// takuhon.schema.json
+var takuhon_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://takuhon.example/schemas/0.1.0/takuhon.schema.json",
+  title: "Takuhon Profile",
+  description: "Portable profile data format consumed by @takuhon/core. The canonical contract for profile content authored as takuhon.json.",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "schemaVersion",
+    "profile",
+    "links",
+    "careers",
+    "projects",
+    "skills",
+    "contact",
+    "settings",
+    "meta"
+  ],
+  properties: {
+    schemaVersion: {
+      type: "string",
+      pattern: "^[0-9]+\\.[0-9]+\\.[0-9]+(-[a-zA-Z0-9.-]+)?$",
+      description: "Semantic version of the takuhon schema this document conforms to."
+    },
+    profile: { $ref: "#/$defs/Profile" },
+    links: {
+      type: "array",
+      maxItems: 100,
+      items: { $ref: "#/$defs/Link" }
+    },
+    careers: {
+      type: "array",
+      maxItems: 50,
+      items: { $ref: "#/$defs/Career" }
+    },
+    projects: {
+      type: "array",
+      maxItems: 100,
+      items: { $ref: "#/$defs/Project" }
+    },
+    skills: {
+      type: "array",
+      maxItems: 200,
+      items: { $ref: "#/$defs/Skill" }
+    },
+    contact: { $ref: "#/$defs/Contact" },
+    settings: { $ref: "#/$defs/Settings" },
+    meta: { $ref: "#/$defs/Meta" }
+  },
+  $defs: {
+    LocaleTag: {
+      type: "string",
+      minLength: 2,
+      maxLength: 35,
+      pattern: "^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{2,8})*$",
+      description: "BCP-47 language tag (e.g., 'en', 'ja', 'zh-Hant', 'pt-BR')."
+    },
+    Iso3166Alpha2: {
+      type: "string",
+      pattern: "^[A-Z]{2}$",
+      description: "ISO 3166-1 alpha-2 country code (uppercase, two letters)."
+    },
+    YearMonth: {
+      type: "string",
+      pattern: "^[0-9]{4}-(0[1-9]|1[0-2])$",
+      description: "Year-month in 'YYYY-MM' format (Gregorian calendar)."
+    },
+    IsoDateTime: {
+      type: "string",
+      format: "date-time",
+      description: "ISO 8601 date-time (e.g., 2026-05-11T12:34:56Z)."
+    },
+    Url: {
+      type: "string",
+      format: "uri",
+      maxLength: 2048
+    },
+    Email: {
+      type: "string",
+      format: "email",
+      maxLength: 254
+    },
+    Slug: {
+      type: "string",
+      minLength: 1,
+      maxLength: 64,
+      pattern: "^[a-z0-9][a-z0-9-]*$",
+      description: "URL-safe identifier (lowercase alphanumerics and hyphens, must start with alphanumeric)."
+    },
+    LocalizedTitle: {
+      type: "object",
+      minProperties: 1,
+      propertyNames: {
+        type: "string",
+        pattern: "^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{2,8})*$"
+      },
+      additionalProperties: {
+        type: "string",
+        minLength: 1,
+        maxLength: 200
+      },
+      description: "Map of BCP-47 locale tag to short title-like string (max 200 chars per value)."
+    },
+    LocalizedBody: {
+      type: "object",
+      minProperties: 1,
+      propertyNames: {
+        type: "string",
+        pattern: "^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{2,8})*$"
+      },
+      additionalProperties: {
+        type: "string",
+        minLength: 1,
+        maxLength: 5e3
+      },
+      description: "Map of BCP-47 locale tag to body-length string (max 5000 chars per value)."
+    },
+    LinkType: {
+      type: "string",
+      enum: [
+        "website",
+        "blog",
+        "github",
+        "gitlab",
+        "linkedin",
+        "x",
+        "mastodon",
+        "bluesky",
+        "instagram",
+        "youtube",
+        "threads",
+        "facebook",
+        "email",
+        "rss",
+        "custom"
+      ],
+      description: "Identifies the kind of link. 'custom' requires iconUrl."
+    },
+    Profile: {
+      type: "object",
+      additionalProperties: true,
+      required: ["displayName"],
+      properties: {
+        displayName: { $ref: "#/$defs/LocalizedTitle" },
+        tagline: { $ref: "#/$defs/LocalizedTitle" },
+        bio: { $ref: "#/$defs/LocalizedBody" },
+        avatar: { $ref: "#/$defs/Avatar" },
+        location: { $ref: "#/$defs/Address" }
+      }
+    },
+    Avatar: {
+      type: "object",
+      additionalProperties: true,
+      required: ["url"],
+      properties: {
+        url: {
+          type: "string",
+          format: "uri-reference",
+          maxLength: 2048,
+          description: "URL or path to the avatar image."
+        },
+        alt: { $ref: "#/$defs/LocalizedTitle" }
+      }
+    },
+    Address: {
+      type: "object",
+      additionalProperties: true,
+      properties: {
+        country: { $ref: "#/$defs/Iso3166Alpha2" },
+        region: { type: "string", maxLength: 100 },
+        locality: { $ref: "#/$defs/LocalizedTitle" },
+        display: { $ref: "#/$defs/LocalizedTitle" }
+      }
+    },
+    Link: {
+      type: "object",
+      additionalProperties: false,
+      required: ["id", "type", "url"],
+      properties: {
+        id: { $ref: "#/$defs/Slug" },
+        type: { $ref: "#/$defs/LinkType" },
+        label: { $ref: "#/$defs/LocalizedTitle" },
+        url: { $ref: "#/$defs/Url" },
+        featured: { type: "boolean" },
+        order: { type: "integer", minimum: 0 },
+        iconUrl: { $ref: "#/$defs/Url" }
+      },
+      allOf: [
+        {
+          if: {
+            properties: { type: { const: "custom" } },
+            required: ["type"]
+          },
+          then: {
+            properties: { iconUrl: { $ref: "#/$defs/Url" } },
+            required: ["iconUrl"]
+          }
+        }
+      ]
+    },
+    Career: {
+      type: "object",
+      additionalProperties: true,
+      required: ["id", "organization", "role", "startDate"],
+      properties: {
+        id: { $ref: "#/$defs/Slug" },
+        organization: { $ref: "#/$defs/LocalizedTitle" },
+        role: { $ref: "#/$defs/LocalizedTitle" },
+        description: { $ref: "#/$defs/LocalizedBody" },
+        startDate: { $ref: "#/$defs/YearMonth" },
+        endDate: {
+          anyOf: [{ $ref: "#/$defs/YearMonth" }, { type: "null" }]
+        },
+        isCurrent: { type: "boolean" },
+        url: { $ref: "#/$defs/Url" },
+        location: { $ref: "#/$defs/Address" },
+        order: { type: "integer", minimum: 0 }
+      }
+    },
+    Project: {
+      type: "object",
+      additionalProperties: true,
+      required: ["id", "title"],
+      properties: {
+        id: { $ref: "#/$defs/Slug" },
+        title: { $ref: "#/$defs/LocalizedTitle" },
+        description: { $ref: "#/$defs/LocalizedBody" },
+        url: { $ref: "#/$defs/Url" },
+        tags: {
+          type: "array",
+          maxItems: 30,
+          items: { type: "string", minLength: 1, maxLength: 50 }
+        },
+        relatedCareerId: { $ref: "#/$defs/Slug" },
+        startDate: { $ref: "#/$defs/YearMonth" },
+        endDate: {
+          anyOf: [{ $ref: "#/$defs/YearMonth" }, { type: "null" }]
+        },
+        highlighted: { type: "boolean" },
+        order: { type: "integer", minimum: 0 }
+      }
+    },
+    Skill: {
+      type: "object",
+      additionalProperties: true,
+      required: ["id", "label"],
+      properties: {
+        id: { $ref: "#/$defs/Slug" },
+        label: { type: "string", minLength: 1, maxLength: 100 },
+        category: {
+          type: "string",
+          minLength: 1,
+          maxLength: 64,
+          description: "Recommended values (extensible): programming, design, business, communication, language, music, art, sports, other."
+        },
+        order: { type: "integer", minimum: 0 }
+      }
+    },
+    Contact: {
+      type: "object",
+      additionalProperties: true,
+      properties: {
+        email: { $ref: "#/$defs/Email" },
+        showEmail: { type: "boolean", default: false },
+        formUrl: { $ref: "#/$defs/Url" }
+      }
+    },
+    Settings: {
+      type: "object",
+      additionalProperties: true,
+      required: ["defaultLocale", "availableLocales"],
+      properties: {
+        defaultLocale: { $ref: "#/$defs/LocaleTag" },
+        fallbackLocale: { $ref: "#/$defs/LocaleTag" },
+        availableLocales: {
+          type: "array",
+          minItems: 1,
+          maxItems: 50,
+          uniqueItems: true,
+          items: { $ref: "#/$defs/LocaleTag" }
+        },
+        theme: {
+          type: "string",
+          minLength: 1,
+          maxLength: 64,
+          description: "UI theme identifier. 'default' is the built-in theme; adapters may add more."
+        },
+        showPoweredBy: {
+          type: "boolean",
+          default: true,
+          description: "Display the 'Powered by takuhon' attribution in the rendered profile."
+        },
+        enableJsonLd: {
+          type: "boolean",
+          default: true,
+          description: "Emit Schema.org JSON-LD on the rendered profile page."
+        },
+        enableApi: {
+          type: "boolean",
+          default: true,
+          description: "Expose the public read API endpoints (GET /api/profile, /api/jsonld, /api/schema, /takuhon.json)."
+        },
+        enableAnalytics: {
+          type: "boolean",
+          default: false,
+          description: "Opt-in flag for first-party analytics. Default is false to keep takuhon privacy-respecting by default."
+        }
+      }
+    },
+    Meta: {
+      type: "object",
+      additionalProperties: true,
+      required: ["contentLicense"],
+      properties: {
+        createdAt: { $ref: "#/$defs/IsoDateTime" },
+        updatedAt: { $ref: "#/$defs/IsoDateTime" },
+        generator: {
+          type: "string",
+          minLength: 1,
+          maxLength: 100,
+          description: "Tool that produced this document (e.g. 'Takuhon', 'create-takuhon@0.1.0')."
+        },
+        contentLicense: { $ref: "#/$defs/ContentLicense" }
+      }
+    },
+    ContentLicense: {
+      type: "object",
+      additionalProperties: false,
+      required: ["spdxId"],
+      properties: {
+        spdxId: {
+          type: "string",
+          minLength: 1,
+          maxLength: 64,
+          description: "SPDX identifier (e.g., 'CC-BY-4.0', 'CC0-1.0') or 'Proprietary'. No default; the profile owner must choose explicitly."
+        },
+        url: { $ref: "#/$defs/Url" },
+        attribution: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            name: { type: "string", minLength: 1, maxLength: 200 },
+            url: { $ref: "#/$defs/Url" }
+          }
+        },
+        rights: {
+          type: "string",
+          minLength: 1,
+          maxLength: 1e3,
+          description: "Free-form rights statement (used when spdxId='Proprietary' or for additional notices)."
+        }
+      }
+    }
+  }
+};
+
+// src/schema.ts
+var schema = takuhon_schema_default;
+
+// src/validate.ts
+import Ajv2020 from "ajv/dist/2020.js";
+import addFormats from "ajv-formats";
+var SUPPORTED_SCHEMA_VERSIONS = ["0.1.0"];
+var ajv = new Ajv2020({
+  allErrors: true,
+  strict: true
+});
+addFormats(ajv);
+var compiled = ajv.compile(schema);
+function validate(data) {
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    return {
+      ok: false,
+      errors: [
+        {
+          pointer: "",
+          message: "takuhon.json must be a JSON object.",
+          keyword: "type"
+        }
+      ]
+    };
+  }
+  const candidate = data;
+  if (typeof candidate.schemaVersion === "string" && !isSupportedVersion(candidate.schemaVersion)) {
+    return {
+      ok: false,
+      errors: [
+        {
+          pointer: "/schemaVersion",
+          message: `schemaVersion "${candidate.schemaVersion}" is not in the supported window (${SUPPORTED_SCHEMA_VERSIONS.join(
+            ", "
+          )}).`,
+          keyword: "schemaVersion"
+        }
+      ]
+    };
+  }
+  if (compiled(data)) {
+    return { ok: true, data };
+  }
+  return {
+    ok: false,
+    errors: (compiled.errors ?? []).map(toValidationError)
+  };
+}
+function isSupportedVersion(value) {
+  return SUPPORTED_SCHEMA_VERSIONS.includes(value);
+}
+function toValidationError(err) {
+  let pointer = err.instancePath;
+  if (err.keyword === "required") {
+    const missing = err.params.missingProperty;
+    if (typeof missing === "string") {
+      pointer = `${err.instancePath}/${escapePointerSegment(missing)}`;
+    }
+  } else if (err.keyword === "additionalProperties") {
+    const extra = err.params.additionalProperty;
+    if (typeof extra === "string") {
+      pointer = `${err.instancePath}/${escapePointerSegment(extra)}`;
+    }
+  }
+  return {
+    pointer,
+    message: err.message ?? "Validation failed.",
+    keyword: err.keyword,
+    schemaPointer: err.schemaPath ? err.schemaPath : void 0
+  };
+}
+function escapePointerSegment(segment) {
+  return segment.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+
+// src/normalize.ts
+function normalize(data) {
+  const out = JSON.parse(JSON.stringify(data));
+  normalizeProfile(out.profile);
+  for (const link of out.links) {
+    cleanOptionalLocalized(link, "label");
+  }
+  out.links = stableSortByOrder(out.links);
+  for (const career of out.careers) {
+    cleanRequiredLocalized(career.organization);
+    cleanRequiredLocalized(career.role);
+    cleanOptionalLocalized(career, "description");
+  }
+  out.careers = stableSortByOrder(out.careers);
+  for (const project of out.projects) {
+    cleanRequiredLocalized(project.title);
+    cleanOptionalLocalized(project, "description");
+  }
+  out.projects = stableSortByOrder(out.projects);
+  out.skills = stableSortByOrder(out.skills);
+  return out;
+}
+function normalizeProfile(profile) {
+  cleanRequiredLocalized(profile.displayName);
+  cleanOptionalLocalized(profile, "tagline");
+  cleanOptionalLocalized(profile, "bio");
+  if (profile.avatar) {
+    cleanOptionalLocalized(profile.avatar, "alt");
+  }
+  if (profile.location) {
+    cleanOptionalLocalized(profile.location, "locality");
+    cleanOptionalLocalized(profile.location, "display");
+  }
+}
+function cleanRequiredLocalized(map) {
+  for (const key of Object.keys(map)) {
+    const value = map[key];
+    if (value === void 0 || value.trim() === "") {
+      delete map[key];
+    }
+  }
+}
+function cleanOptionalLocalized(parent, key) {
+  const map = parent[key];
+  if (!map) return;
+  for (const k of Object.keys(map)) {
+    const value = map[k];
+    if (value === void 0 || value.trim() === "") {
+      delete map[k];
+    }
+  }
+  if (Object.keys(map).length === 0) {
+    delete parent[key];
+  }
+}
+function stableSortByOrder(items) {
+  return items.slice().sort((a, b) => {
+    const ao = a.order ?? Number.POSITIVE_INFINITY;
+    const bo = b.order ?? Number.POSITIVE_INFINITY;
+    return ao - bo;
+  });
+}
+
+// src/locale-tag.ts
+var BCP47_PATTERN = /^[a-zA-Z]{2,3}(-[a-zA-Z0-9]+)*$/;
+function isValidBcp47(tag) {
+  return BCP47_PATTERN.test(tag);
+}
+function expandRegional(tag) {
+  if (!isValidBcp47(tag)) return [];
+  const parts = tag.split("-");
+  const out = [];
+  for (let i = parts.length; i >= 1; i--) {
+    out.push(parts.slice(0, i).join("-"));
+  }
+  return out;
+}
+function lookupCaseInsensitive(map, key) {
+  if (!map) return void 0;
+  const direct = map[key];
+  if (direct !== void 0) return direct;
+  const lower = key.toLowerCase();
+  for (const k of Object.keys(map)) {
+    if (k.toLowerCase() === lower) return map[k];
+  }
+  return void 0;
+}
+
+// src/resolve-locale.ts
+function resolveLocale(data, locale, fallbackLocale) {
+  const candidates = buildCandidates(data, locale, fallbackLocale);
+  const displayPick = pickLocalizedWithTag(data.profile.displayName, candidates);
+  return {
+    schemaVersion: data.schemaVersion,
+    profile: resolveProfile(data.profile, candidates, displayPick?.value ?? ""),
+    links: data.links.map((l) => resolveLink(l, candidates)),
+    careers: data.careers.map((c) => resolveCareer(c, candidates)),
+    projects: data.projects.map((p) => resolveProject(p, candidates)),
+    skills: data.skills,
+    contact: data.contact,
+    settings: data.settings,
+    meta: data.meta,
+    resolvedLocale: displayPick?.tag ?? candidates[0] ?? ""
+  };
+}
+function buildCandidates(data, locale, fallbackLocale) {
+  const raw = [];
+  if (locale !== void 0) raw.push(...expandRegional(locale));
+  if (fallbackLocale !== void 0) raw.push(...expandRegional(fallbackLocale));
+  raw.push(...expandRegional(data.settings.defaultLocale));
+  if (data.settings.fallbackLocale !== void 0) {
+    raw.push(...expandRegional(data.settings.fallbackLocale));
+  }
+  for (const tag of data.settings.availableLocales) {
+    raw.push(...expandRegional(tag));
+  }
+  return dedupCaseInsensitive(raw);
+}
+function dedupCaseInsensitive(tags) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const tag of tags) {
+    if (!isValidBcp47(tag)) continue;
+    const lower = tag.toLowerCase();
+    if (seen.has(lower)) continue;
+    seen.add(lower);
+    out.push(tag);
+  }
+  return out;
+}
+function pickLocalizedWithTag(field, candidates) {
+  if (!field) return void 0;
+  for (const tag of candidates) {
+    const hit = lookupCaseInsensitive(field, tag);
+    if (hit !== void 0 && hit.trim() !== "") {
+      return { value: hit, tag };
+    }
+  }
+  return void 0;
+}
+function pickLocalized(field, candidates) {
+  return pickLocalizedWithTag(field, candidates)?.value;
+}
+function resolveProfile(profile, candidates, displayName) {
+  const out = { displayName };
+  const tagline = pickLocalized(profile.tagline, candidates);
+  if (tagline !== void 0) out.tagline = tagline;
+  const bio = pickLocalized(profile.bio, candidates);
+  if (bio !== void 0) out.bio = bio;
+  if (profile.avatar) out.avatar = resolveAvatar(profile.avatar, candidates);
+  if (profile.location) out.location = resolveAddress(profile.location, candidates);
+  return out;
+}
+function resolveAvatar(avatar, candidates) {
+  const out = { url: avatar.url };
+  const alt = pickLocalized(avatar.alt, candidates);
+  if (alt !== void 0) out.alt = alt;
+  return out;
+}
+function resolveAddress(address, candidates) {
+  const out = {};
+  if (address.country !== void 0) out.country = address.country;
+  if (address.region !== void 0) out.region = address.region;
+  const locality = pickLocalized(address.locality, candidates);
+  if (locality !== void 0) out.locality = locality;
+  const display = pickLocalized(address.display, candidates);
+  if (display !== void 0) out.display = display;
+  return out;
+}
+function resolveLink(link, candidates) {
+  const label = pickLocalized(link.label, candidates);
+  if (link.type === "custom") {
+    const out2 = {
+      id: link.id,
+      type: "custom",
+      url: link.url,
+      iconUrl: link.iconUrl
+    };
+    if (label !== void 0) out2.label = label;
+    if (link.featured !== void 0) out2.featured = link.featured;
+    if (link.order !== void 0) out2.order = link.order;
+    return out2;
+  }
+  const out = {
+    id: link.id,
+    type: link.type,
+    url: link.url
+  };
+  if (label !== void 0) out.label = label;
+  if (link.featured !== void 0) out.featured = link.featured;
+  if (link.order !== void 0) out.order = link.order;
+  if (link.iconUrl !== void 0) out.iconUrl = link.iconUrl;
+  return out;
+}
+function resolveCareer(career, candidates) {
+  const out = {
+    id: career.id,
+    organization: pickLocalized(career.organization, candidates) ?? "",
+    role: pickLocalized(career.role, candidates) ?? "",
+    startDate: career.startDate
+  };
+  const description = pickLocalized(career.description, candidates);
+  if (description !== void 0) out.description = description;
+  if (career.endDate !== void 0) out.endDate = career.endDate;
+  if (career.isCurrent !== void 0) out.isCurrent = career.isCurrent;
+  if (career.url !== void 0) out.url = career.url;
+  if (career.order !== void 0) out.order = career.order;
+  if (career.location) out.location = resolveAddress(career.location, candidates);
+  return out;
+}
+function resolveProject(project, candidates) {
+  const out = {
+    id: project.id,
+    title: pickLocalized(project.title, candidates) ?? ""
+  };
+  const description = pickLocalized(project.description, candidates);
+  if (description !== void 0) out.description = description;
+  if (project.url !== void 0) out.url = project.url;
+  if (project.tags !== void 0) out.tags = project.tags;
+  if (project.relatedCareerId !== void 0) out.relatedCareerId = project.relatedCareerId;
+  if (project.startDate !== void 0) out.startDate = project.startDate;
+  if (project.endDate !== void 0) out.endDate = project.endDate;
+  if (project.highlighted !== void 0) out.highlighted = project.highlighted;
+  if (project.order !== void 0) out.order = project.order;
+  return out;
+}
+
+// src/jsonld.ts
+var SAMEAS_IDENTITY_TYPES = /* @__PURE__ */ new Set([
+  "github",
+  "gitlab",
+  "linkedin",
+  "x",
+  "mastodon",
+  "bluesky",
+  "instagram",
+  "youtube",
+  "threads",
+  "facebook",
+  "website",
+  "blog"
+]);
+function generatePersonJsonLd(data) {
+  const person = buildPerson(data, deriveCanonicalUrl(data));
+  return { "@context": "https://schema.org", ...person };
+}
+function generateProfilePageJsonLd(data) {
+  const canonicalUrl = deriveCanonicalUrl(data);
+  const person = buildPerson(data, canonicalUrl);
+  const out = {};
+  out["@context"] = "https://schema.org";
+  out["@type"] = "ProfilePage";
+  if (canonicalUrl !== void 0) out.url = canonicalUrl;
+  out.inLanguage = data.resolvedLocale;
+  if (data.meta.createdAt !== void 0) out.dateCreated = data.meta.createdAt;
+  if (data.meta.updatedAt !== void 0) out.dateModified = data.meta.updatedAt;
+  if (data.profile.avatar !== void 0) out.primaryImageOfPage = data.profile.avatar.url;
+  out.mainEntity = person;
+  return out;
+}
+function generateJsonLd(data) {
+  return [generateProfilePageJsonLd(data)];
+}
+function deriveCanonicalUrl(data) {
+  const featured = data.links.find((l) => l.type === "website" && l.featured === true);
+  return featured?.url;
+}
+function buildPerson(data, canonicalUrl) {
+  const { profile, careers, projects, links, skills, contact } = data;
+  const out = {};
+  out["@type"] = "Person";
+  if (canonicalUrl !== void 0) out["@id"] = `${canonicalUrl}#person`;
+  out.name = profile.displayName;
+  if (profile.bio !== void 0) out.description = profile.bio;
+  const image = buildImage(profile.avatar);
+  if (image !== void 0) out.image = image;
+  if (canonicalUrl !== void 0) out.url = canonicalUrl;
+  const { current, past } = partitionCareers(careers);
+  const roleFields = buildCurrentRoleFields(current);
+  if (roleFields.jobTitle !== void 0) out.jobTitle = roleFields.jobTitle;
+  if (roleFields.worksFor !== void 0) out.worksFor = roleFields.worksFor;
+  const address = buildAddress(profile.location);
+  if (address !== void 0) out.address = address;
+  const email = buildEmail(contact);
+  if (email !== void 0) out.email = email;
+  const knowsAbout = buildKnowsAbout(skills);
+  if (knowsAbout !== void 0) out.knowsAbout = knowsAbout;
+  const sameAs = buildSameAs(links);
+  if (sameAs !== void 0) out.sameAs = sameAs;
+  const subjectOf = [...buildPastRoles(past), ...buildProjects(projects)];
+  if (subjectOf.length > 0) out.subjectOf = subjectOf;
+  return out;
+}
+function buildImage(avatar) {
+  if (!avatar) return void 0;
+  const out = {};
+  out["@type"] = "ImageObject";
+  out.url = avatar.url;
+  if (avatar.alt !== void 0) out.caption = avatar.alt;
+  return out;
+}
+function buildAddress(location) {
+  if (!location) return void 0;
+  const hasAny = location.country !== void 0 || location.region !== void 0 || location.locality !== void 0;
+  if (!hasAny) return void 0;
+  const out = {};
+  out["@type"] = "PostalAddress";
+  if (location.country !== void 0) out.addressCountry = location.country;
+  if (location.region !== void 0) out.addressRegion = location.region;
+  if (location.locality !== void 0) out.addressLocality = location.locality;
+  return out;
+}
+function partitionCareers(careers) {
+  const current = [];
+  const past = [];
+  for (const c of careers) {
+    if (c.isCurrent === true) current.push(c);
+    else past.push(c);
+  }
+  return { current, past };
+}
+function buildCurrentRoleFields(current) {
+  const head = current[0];
+  if (head === void 0) return {};
+  const out = {};
+  if (head.role !== "") out.jobTitle = head.role;
+  out.worksFor = buildWorksFor(head);
+  return out;
+}
+function buildWorksFor(career) {
+  const out = {};
+  out["@type"] = "Organization";
+  out.name = career.organization;
+  if (career.url !== void 0) out.url = career.url;
+  return out;
+}
+function buildPastRoles(past) {
+  return past.map((c) => {
+    const out = {};
+    out["@type"] = "WorkRole";
+    out.name = c.role;
+    out.memberOf = { "@type": "Organization", name: c.organization };
+    out.startDate = c.startDate;
+    if (c.endDate !== void 0 && c.endDate !== null) out.endDate = c.endDate;
+    return out;
+  });
+}
+function buildProjects(projects) {
+  return projects.map((p) => {
+    const out = {};
+    out["@type"] = "CreativeWork";
+    out.name = p.title;
+    if (p.url !== void 0) out.url = p.url;
+    if (p.startDate !== void 0) out.datePublished = p.startDate;
+    if (p.tags !== void 0 && p.tags.length > 0) out.about = p.tags;
+    return out;
+  });
+}
+function buildSameAs(links) {
+  const out = links.filter((l) => SAMEAS_IDENTITY_TYPES.has(l.type)).map((l) => l.url);
+  return out.length === 0 ? void 0 : out;
+}
+function buildKnowsAbout(skills) {
+  if (skills.length === 0) return void 0;
+  return skills.map((s) => s.label);
+}
+function buildEmail(contact) {
+  if (contact.showEmail !== true) return void 0;
+  if (typeof contact.email !== "string" || contact.email.length === 0) return void 0;
+  return contact.email;
+}
+
+// src/export.ts
+var ImportError = class extends Error {
+  errors;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "ImportError";
+    this.errors = options?.errors;
+  }
+};
+function exportTakuhon(data, options = {}) {
+  const out = JSON.parse(JSON.stringify(data));
+  if (options.updateTimestamp !== false) {
+    out.meta = { ...out.meta, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  return out;
+}
+function importTakuhon(data) {
+  const result = validate(data);
+  if (!result.ok) {
+    throw new ImportError("imported document failed schema validation", { errors: result.errors });
+  }
+  return JSON.parse(JSON.stringify(result.data));
+}
+
+// src/migrations/_chain.ts
+function findMigrationChain(from, to, registry) {
+  if (from === to) return [];
+  const byFrom = /* @__PURE__ */ new Map();
+  for (const m of registry) byFrom.set(m.from, m);
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set([from]);
+  let cur = from;
+  while (cur !== to) {
+    const next = byFrom.get(cur);
+    if (!next) return null;
+    if (visited.has(next.to)) return null;
+    chain.push(next);
+    visited.add(next.to);
+    cur = next.to;
+  }
+  return chain;
+}
+
+// src/migrations/index.ts
+var migrations = [];
+
+// src/migrate.ts
+var MigrationError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "MigrationError";
+  }
+};
+function migrateTakuhon(data, targetVersion) {
+  const sourceVersion = data.schemaVersion;
+  if (sourceVersion === targetVersion) {
+    return JSON.parse(JSON.stringify(data));
+  }
+  const chain = findMigrationChain(sourceVersion, targetVersion, migrations);
+  if (!chain) {
+    throw new MigrationError(`No migration path from ${sourceVersion} to ${targetVersion}`);
+  }
+  let current = JSON.parse(JSON.stringify(data));
+  for (const step of chain) {
+    current = step.migrate(current);
+  }
+  return current;
+}
+
+// src/storage-interface.ts
+var StorageError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "StorageError";
+  }
+};
+var NotFoundError = class extends StorageError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends StorageError {
+  currentVersion;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "ConflictError";
+    this.currentVersion = options?.currentVersion;
+  }
+};
+
+// src/index.ts
+var SCHEMA_VERSION = "0.1.0";
+export {
+  ConflictError,
+  ImportError,
+  MigrationError,
+  NotFoundError,
+  SCHEMA_VERSION,
+  SUPPORTED_SCHEMA_VERSIONS,
+  StorageError,
+  exportTakuhon,
+  generateJsonLd,
+  generatePersonJsonLd,
+  generateProfilePageJsonLd,
+  importTakuhon,
+  migrateTakuhon,
+  migrations,
+  normalize,
+  resolveLocale,
+  schema,
+  validate
+};
+//# sourceMappingURL=index.js.map