@sorane/core 0.2.0

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@sorane/core",
+  "version": "0.2.0",
+  "description": "OKF-native static site build engine for sorane",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/masanork/sorane.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://sorane.dev",
+  "bugs": "https://github.com/masanork/sorane/issues",
+  "files": [
+    "src"
+  ],
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "engines": {
+    "node": ">=23.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@mermaid-js/mermaid-cli": "~11.15.0",
+    "@sorane/font": "0.2.0",
+    "@sorane/okf": "0.2.0",
+    "@sorane/search": "0.2.0",
+    "mermaid": "~11.15.0",
+    "rehype-autolink-headings": "^7.1.0",
+    "rehype-raw": "^7.0.0",
+    "rehype-sanitize": "^6.0.0",
+    "rehype-stringify": "^10.0.1",
+    "remark-gfm": "^4.0.1",
+    "remark-parse": "^11.0.0",
+    "remark-rehype": "^11.1.2",
+    "unified": "^11.0.0",
+    "unist-util-visit": "^5.1.0"
+  }
+}

package/src/ai-disclosure.ts

@@ -0,0 +1,181 @@
+import {
+  inferEuLabel,
+  parseAiSystems,
+  parseEuAiLabel,
+  resolveDigitalSourceType,
+  showsEuBadge,
+  type AiSystemRef,
+  type EuAiLabel,
+} from "@sorane/okf";
+import { escapeHtml } from "./render.ts";
+import { siteLabels } from "./site-labels.ts";
+
+export type { AiSystemRef, EuAiLabel };
+
+export interface AiDisclosure {
+  readonly digitalSourceType: string;
+  readonly digitalSourceCode: string;
+  readonly euLabel?: EuAiLabel;
+  readonly note?: string;
+  readonly systems?: readonly AiSystemRef[];
+  readonly showBadge: boolean;
+}
+
+export interface AiDisclosureConfig {
+  readonly enabled?: boolean;
+  readonly badges?: boolean;
+  readonly json_ld?: boolean;
+  readonly machine_readable?: boolean;
+  readonly atom?: boolean;
+  readonly show_on_lists?: boolean;
+  readonly policy_url?: string;
+}
+
+export interface ResolvedAiDisclosureFlags {
+  readonly badges: boolean;
+  readonly jsonLd: boolean;
+  readonly machineReadable: boolean;
+  readonly atom: boolean;
+  readonly showOnLists: boolean;
+  readonly policyUrl?: string;
+}
+
+export function parseAiDisclosure(
+  frontmatter: Record<string, unknown>,
+): AiDisclosure | null {
+  const raw = frontmatter.digitalSourceType;
+  if (typeof raw !== "string" || raw.trim().length === 0) return null;
+
+  const resolved = resolveDigitalSourceType(raw);
+  if (!resolved) return null;
+
+  const euOverride = parseEuAiLabel(frontmatter.euAiLabel);
+  const note =
+    typeof frontmatter.aiDisclosureNote === "string" &&
+    frontmatter.aiDisclosureNote.trim().length > 0
+      ? frontmatter.aiDisclosureNote.trim()
+      : undefined;
+  const systems = parseAiSystems(frontmatter.aiSystems);
+
+  const showBadge = showsEuBadge(resolved.code, euOverride);
+  const euLabel = showBadge
+    ? (euOverride ?? inferEuLabel(resolved.code))
+    : euOverride;
+
+  return {
+    digitalSourceType: resolved.uri,
+    digitalSourceCode: resolved.code,
+    euLabel,
+    note,
+    systems,
+    showBadge: showBadge && euLabel !== undefined,
+  };
+}
+
+export function resolveAiDisclosureFlags(
+  config: AiDisclosureConfig | undefined,
+  hasDisclosureOnPage: boolean,
+): ResolvedAiDisclosureFlags {
+  const enabled = config?.enabled !== false;
+  const badges = config?.badges ?? enabled;
+  const jsonLd =
+    config?.json_ld ?? (hasDisclosureOnPage ? true : false);
+  const machineReadable =
+    config?.machine_readable ?? (hasDisclosureOnPage ? true : false);
+  const atom = config?.atom ?? machineReadable;
+  const showOnLists = config?.show_on_lists ?? false;
+
+  return {
+    badges: badges && hasDisclosureOnPage,
+    jsonLd: jsonLd && hasDisclosureOnPage,
+    machineReadable: machineReadable && hasDisclosureOnPage,
+    atom: atom && hasDisclosureOnPage,
+    showOnLists: showOnLists && hasDisclosureOnPage,
+    policyUrl: config?.policy_url,
+  };
+}
+
+function euLabelFile(label: EuAiLabel): string {
+  if (label === "fully-generated") return "fully-generated";
+  if (label === "partially-modified") return "partially-modified";
+  return "basic";
+}
+
+function disclosureTitle(label: EuAiLabel, lang: string): string {
+  const ja = lang.startsWith("ja");
+  if (label === "fully-generated") {
+    return ja ? "AI により完全生成されたコンテンツ" : "Fully AI-generated content";
+  }
+  if (label === "partially-modified") {
+    return ja ? "AI により部分的に改変されたコンテンツ" : "Partially AI-modified content";
+  }
+  return ja ? "AI が関与したコンテンツ" : "AI-involved content";
+}
+
+export function buildAiBadgeHtml(
+  d: AiDisclosure,
+  opts: {
+    readonly lang: string;
+    readonly rootPrefix: string;
+    readonly policyUrl?: string;
+  },
+): string {
+  if (!d.showBadge || !d.euLabel) return "";
+  const label = d.euLabel;
+  const icon = `${opts.rootPrefix}assets/ai-labels/${euLabelFile(label)}.svg`;
+  const title = disclosureTitle(label, opts.lang);
+  const detail = d.note ? `<p class="ai-disclosure-detail">${escapeHtml(d.note)}</p>` : "";
+  const policy = opts.policyUrl
+    ? `<p class="ai-disclosure-policy"><a href="${escapeHtml(opts.policyUrl)}">${escapeHtml(siteLabels(opts.lang).aiPolicyLink)}</a></p>`
+    : "";
+  const meta =
+    `<p class="ai-disclosure-meta">` +
+    `<a href="${escapeHtml(d.digitalSourceType)}" rel="external noopener">` +
+    `IPTC: ${escapeHtml(d.digitalSourceCode)}</a></p>`;
+  return (
+    `<aside class="ai-disclosure ai-disclosure--${escapeHtml(label)}" role="note" ` +
+    `aria-label="${escapeHtml(siteLabels(opts.lang).aiDisclosureAria)}">\n` +
+    `<img class="ai-disclosure-icon" src="${escapeHtml(icon)}" alt="" width="32" height="32" decoding="async" />\n` +
+    `<div class="ai-disclosure-text">\n` +
+    `<p class="ai-disclosure-title">${escapeHtml(title)}</p>\n` +
+    `${detail}\n` +
+    `${meta}\n` +
+    `${policy}\n` +
+    `</div>\n` +
+    `</aside>\n`
+  );
+}
+
+export function buildCompactAiBadgeHtml(
+  d: AiDisclosure,
+  opts: { readonly rootPrefix: string },
+): string {
+  if (!d.showBadge || !d.euLabel) return "";
+  const icon = `${opts.rootPrefix}assets/ai-labels/${euLabelFile(d.euLabel)}.svg`;
+  return (
+    `<img class="ai-disclosure-compact" src="${escapeHtml(icon)}" ` +
+    `alt="AI" width="20" height="20" decoding="async" />\n`
+  );
+}
+
+export function aiDisclosureJsonLdFields(
+  d: AiDisclosure,
+): Record<string, unknown> {
+  const fields: Record<string, unknown> = {
+    digitalSourceType: d.digitalSourceType,
+  };
+  if (d.note) {
+    fields.disambiguatingDescription = d.note;
+  }
+  if (d.systems?.length) {
+    fields.contributor = d.systems.map((s) => ({
+      "@type": "SoftwareApplication",
+      name: s.name,
+      ...(s.version ? { softwareVersion: s.version } : {}),
+      ...(s.provider
+        ? { author: { "@type": "Organization", name: s.provider } }
+        : {}),
+    }));
+  }
+  return fields;
+}

package/src/asset-provenance.ts

@@ -0,0 +1,141 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { parseYaml } from "@sorane/okf";
+import { resolveDigitalSourceType } from "@sorane/okf";
+
+export interface AssetAiSystemEntry {
+  readonly name: string;
+  readonly version?: string;
+  readonly provider?: string;
+}
+
+export interface AssetProvenanceEntry {
+  readonly digitalSourceType?: string;
+  readonly aiDisclosureNote?: string;
+  readonly createIntent?: string;
+  readonly aiSystems?: readonly AssetAiSystemEntry[];
+}
+
+export type AssetProvenanceMap = Readonly<Record<string, AssetProvenanceEntry>>;
+
+const DEFAULT_MANIFEST_REL = "asset-provenance.yaml";
+
+function parseAssetAiSystems(raw: unknown): readonly AssetAiSystemEntry[] | undefined {
+  if (!Array.isArray(raw) || raw.length === 0) return undefined;
+  const out: AssetAiSystemEntry[] = [];
+  for (const item of raw) {
+    if (item === null || typeof item !== "object" || Array.isArray(item)) continue;
+    const row = item as Record<string, unknown>;
+    const name = typeof row.name === "string" ? row.name.trim() : "";
+    if (name.length === 0) continue;
+    out.push({
+      name,
+      version: typeof row.version === "string" ? row.version : undefined,
+      provider: typeof row.provider === "string" ? row.provider : undefined,
+    });
+  }
+  return out.length > 0 ? out : undefined;
+}
+
+function normalizeAssetKey(key: string): string {
+  return key.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+
+/** `content/asset-provenance.yaml` を読み込む（無ければ空）。 */
+export function loadAssetProvenance(
+  contentDir: string,
+  manifestRel = DEFAULT_MANIFEST_REL,
+): AssetProvenanceMap {
+  const path = resolve(contentDir, manifestRel);
+  if (!existsSync(path)) return {};
+  const raw = parseYaml(readFileSync(path, "utf8"));
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const assets = (raw as Record<string, unknown>).assets;
+  if (assets === null || typeof assets !== "object" || Array.isArray(assets)) return {};
+
+  const out: Record<string, AssetProvenanceEntry> = {};
+  for (const [key, value] of Object.entries(assets as Record<string, unknown>)) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) continue;
+    const entry = value as Record<string, unknown>;
+    const dst =
+      typeof entry.digitalSourceType === "string" ? entry.digitalSourceType : undefined;
+    const note =
+      typeof entry.aiDisclosureNote === "string" ? entry.aiDisclosureNote : undefined;
+    const createIntent =
+      typeof entry.createIntent === "string" ? entry.createIntent : undefined;
+    const aiSystems = parseAssetAiSystems(entry.aiSystems);
+    out[normalizeAssetKey(key)] = {
+      digitalSourceType: dst,
+      aiDisclosureNote: note,
+      createIntent,
+      aiSystems,
+    };
+  }
+  return out;
+}
+
+export interface ProvenanceLookupHints {
+  readonly staticRel?: string;
+  readonly markdownPath?: string;
+  readonly publicPath?: string;
+  readonly contentRel?: string;
+  readonly sourceMdRel?: string;
+}
+
+function provenanceCandidates(hints: ProvenanceLookupHints): string[] {
+  const out: string[] = [];
+  const push = (value: string | undefined) => {
+    if (!value) return;
+    const key = normalizeAssetKey(value);
+    if (key.length > 0 && !out.includes(key)) out.push(key);
+  };
+
+  push(hints.staticRel);
+  push(hints.markdownPath);
+  push(hints.publicPath);
+  push(hints.contentRel);
+  if (hints.staticRel) push(join("static", hints.staticRel).replace(/\\/g, "/"));
+  if (hints.publicPath?.startsWith("static/")) {
+    push(hints.publicPath.slice("static/".length));
+  }
+  if (hints.sourceMdRel && hints.markdownPath) {
+    const sourceDir = hints.sourceMdRel.includes("/")
+      ? hints.sourceMdRel.replace(/\/[^/]+$/, "")
+      : "";
+    push(sourceDir.length > 0 ? `${sourceDir}/${hints.markdownPath}` : hints.markdownPath);
+  }
+  return out;
+}
+
+export function lookupAssetProvenance(
+  map: AssetProvenanceMap,
+  hints: string | ProvenanceLookupHints,
+): AssetProvenanceEntry | undefined {
+  const keys =
+    typeof hints === "string"
+      ? provenanceCandidates({ staticRel: hints })
+      : provenanceCandidates(hints);
+  for (const key of keys) {
+    const entry = map[key];
+    if (entry) return entry;
+  }
+  return undefined;
+}
+
+/** C2PA `--create` に渡す IPTC 短コードを解決する。 */
+export function resolveC2paCreateIntent(
+  entry: AssetProvenanceEntry | undefined,
+  fallback = "digitalCapture",
+): string {
+  if (entry?.createIntent) return entry.createIntent;
+  const dst = entry?.digitalSourceType;
+  if (!dst) return fallback;
+  const resolved = resolveDigitalSourceType(dst);
+  if (!resolved) return fallback;
+  const code = resolved.code;
+  if (code === "trainedAlgorithmicMedia" || code === "compositeWithTrainedAlgorithmicMedia") {
+    return code;
+  }
+  if (code === "digitalCreation" || code === "humanEdits") return "digitalCapture";
+  return fallback;
+}

package/src/associated-media.ts

@@ -0,0 +1,93 @@
+import { resolveDigitalSourceType } from "@sorane/okf";
+import {
+  lookupAssetProvenance,
+  type AssetProvenanceEntry,
+  type AssetProvenanceMap,
+} from "./asset-provenance.ts";
+import { hasImageMetadataFields } from "./iptc-xmp-pass.ts";
+import type { MarkdownImageRef } from "./markdown-image-refs.ts";
+
+export interface AssociatedMediaItem {
+  readonly contentUrl: string;
+  readonly digitalSourceType: string;
+  readonly name?: string;
+  readonly encodingFormat?: string;
+}
+
+function encodingFormatFromPath(filePath: string): string | undefined {
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  if (ext === "jpg" || ext === "jpeg") return "image/jpeg";
+  if (ext === "png") return "image/png";
+  if (ext === "webp") return "image/webp";
+  return undefined;
+}
+
+function provenanceForRef(
+  map: AssetProvenanceMap,
+  ref: MarkdownImageRef,
+): AssetProvenanceEntry | undefined {
+  return lookupAssetProvenance(map, {
+    staticRel: ref.kind === "static" ? ref.publicPath.replace(/^static\//, "") : undefined,
+    markdownPath: ref.markdownPath,
+    publicPath: ref.publicPath,
+    contentRel: ref.publicPath,
+    sourceMdRel: ref.sourceMdRel,
+  });
+}
+
+function toAssociatedMediaItem(
+  ref: MarkdownImageRef,
+  entry: AssetProvenanceEntry,
+  baseUrl: string,
+): AssociatedMediaItem | null {
+  const dst = entry.digitalSourceType;
+  if (!dst) return null;
+  const resolved = resolveDigitalSourceType(dst);
+  if (!resolved) return null;
+
+  const path = ref.publicPath.startsWith("/") ? ref.publicPath : `/${ref.publicPath}`;
+  const contentUrl =
+    baseUrl.length > 0 ? `${baseUrl.replace(/\/$/, "")}${path}` : path.replace(/^\//, "");
+
+  return {
+    contentUrl,
+    digitalSourceType: resolved.uri,
+    ...(ref.alt.length > 0 ? { name: ref.alt } : {}),
+    encodingFormat: encodingFormatFromPath(ref.publicPath),
+  };
+}
+
+/** 記事本文のインライン画像から `associatedMedia` 用 ImageObject 配列を組み立てる。 */
+export function buildAssociatedMediaForArticle(opts: {
+  readonly refs: readonly MarkdownImageRef[];
+  readonly provenance: AssetProvenanceMap;
+  readonly baseUrl: string;
+}): AssociatedMediaItem[] {
+  const out: AssociatedMediaItem[] = [];
+  const seen = new Set<string>();
+
+  for (const ref of opts.refs) {
+    const entry = provenanceForRef(opts.provenance, ref);
+    if (!hasImageMetadataFields(entry)) continue;
+    const item = toAssociatedMediaItem(ref, entry!, opts.baseUrl);
+    if (!item || seen.has(item.contentUrl)) continue;
+    seen.add(item.contentUrl);
+    out.push(item);
+  }
+  return out;
+}
+
+export function associatedMediaJsonLdFields(
+  items: readonly AssociatedMediaItem[],
+): Record<string, unknown> | null {
+  if (items.length === 0) return null;
+  return {
+    associatedMedia: items.map((item) => ({
+      "@type": "ImageObject",
+      contentUrl: item.contentUrl,
+      digitalSourceType: item.digitalSourceType,
+      ...(item.name ? { name: item.name } : {}),
+      ...(item.encodingFormat ? { encodingFormat: item.encodingFormat } : {}),
+    })),
+  };
+}

package/src/blog-pages.ts

@@ -0,0 +1,175 @@
+import { buildCompactAiBadgeHtml } from "./ai-disclosure.ts";
+import type { ArticleListEntry } from "./ssg.ts";
+import { escapeHtml } from "./render.ts";
+import { relLinkFrom, renderBlogIndexBody, slugifyTag } from "./ssg.ts";
+
+export { slugifyTag };
+
+export function groupByYearMonth(
+  articles: readonly ArticleListEntry[],
+): Map<string, ArticleListEntry[]> {
+  const byMonth = new Map<string, ArticleListEntry[]>();
+  for (const a of articles) {
+    const ym = a.timestamp?.slice(0, 7);
+    if (!ym) continue;
+    const list = byMonth.get(ym) ?? [];
+    list.push(a);
+    byMonth.set(ym, list);
+  }
+  return byMonth;
+}
+
+export function groupByYear(
+  articles: readonly ArticleListEntry[],
+): Map<string, ArticleListEntry[]> {
+  const byYear = new Map<string, ArticleListEntry[]>();
+  for (const a of articles) {
+    const y = a.timestamp?.slice(0, 4);
+    if (!y) continue;
+    const list = byYear.get(y) ?? [];
+    list.push(a);
+    byYear.set(y, list);
+  }
+  return byYear;
+}
+
+export function groupByTag(
+  articles: readonly ArticleListEntry[],
+): Map<string, ArticleListEntry[]> {
+  const byTag = new Map<string, ArticleListEntry[]>();
+  for (const a of articles) {
+    for (const tag of a.tags ?? []) {
+      const slug = slugifyTag(tag);
+      if (!slug) continue;
+      const list = byTag.get(slug) ?? [];
+      list.push(a);
+      byTag.set(slug, list);
+    }
+  }
+  return byTag;
+}
+
+export function paginate<T>(items: readonly T[], pageSize: number): T[][] {
+  const pages: T[][] = [];
+  for (let i = 0; i < items.length; i += pageSize) {
+    pages.push(items.slice(i, i + pageSize));
+  }
+  return pages;
+}
+
+export function blogPaginationRel(page: number): string {
+  return page <= 1 ? "index.html" : `page/${page}.html`;
+}
+
+export function renderArchiveListBody(
+  title: string,
+  description: string | undefined,
+  articles: readonly ArticleListEntry[],
+  opts?: {
+    fromRel: string;
+    page?: number;
+    totalPages?: number;
+    showOnLists?: boolean;
+    listRootPrefix?: string;
+  },
+): string {
+  const fromRel = opts?.fromRel ?? "index.html";
+  const listPrefix = opts?.listRootPrefix ?? relLinkFrom(fromRel, "index.html").replace(/index\.html$/, "");
+  const items = articles
+    .map((a) => {
+      const date = a.timestamp?.slice(0, 10) ?? "";
+      const dateHtml = date
+        ? `<time datetime="${escapeHtml(date)}">${escapeHtml(date)}</time> · `
+        : "";
+      const href = relLinkFrom(fromRel, a.href);
+      const badge =
+        opts?.showOnLists && a.aiDisclosure?.showBadge
+          ? buildCompactAiBadgeHtml(a.aiDisclosure, { rootPrefix: listPrefix })
+          : "";
+      return (
+        `<li class="blog-list-item">` +
+        `${dateHtml}<a href="${escapeHtml(href)}" class="blog-list-title">${escapeHtml(a.title)}</a>` +
+        `${badge}` +
+        `</li>`
+      );
+    })
+    .join("\n");
+
+  let pager = "";
+  const page = opts?.page;
+  const totalPages = opts?.totalPages;
+  if (page !== undefined && totalPages !== undefined && totalPages > 1) {
+    const parts: string[] = [];
+    if (page > 1) {
+      parts.push(
+        `<a href="${escapeHtml(relLinkFrom(fromRel, blogPaginationRel(page - 1)))}" rel="prev">← 前へ</a>`,
+      );
+    }
+    parts.push(`<span>${page} / ${totalPages}</span>`);
+    if (page < totalPages) {
+      parts.push(
+        `<a href="${escapeHtml(relLinkFrom(fromRel, blogPaginationRel(page + 1)))}" rel="next">次へ →</a>`,
+      );
+    }
+    pager = `<nav class="blog-pagination" aria-label="ページ">${parts.join(" · ")}</nav>`;
+  }
+
+  return (
+    `<div class="blog-index">\n` +
+    `<header class="blog-header"><h1>${escapeHtml(title)}</h1>` +
+    (description ? `<p class="blog-lead">${escapeHtml(description)}</p>` : "") +
+    `</header>\n` +
+    `<ul class="blog-list">\n${items}\n</ul>\n` +
+    `${pager}\n` +
+    `</div>\n`
+  );
+}
+
+export function renderYearArchiveIndexBody(
+  siteTitle: string,
+  byYear: Map<string, ArticleListEntry[]>,
+  fromRel = "archive/index.html",
+): string {
+  const years = [...byYear.keys()].sort((a, b) => b.localeCompare(a));
+  const items = years
+    .map((y) => {
+      const count = byYear.get(y)!.length;
+      const href = relLinkFrom(fromRel, `archive/${y}.html`);
+      return `<li><a href="${escapeHtml(href)}">${escapeHtml(y)}</a> (${count})</li>`;
+    })
+    .join("\n");
+  return (
+    `<div class="blog-index">\n` +
+    `<header class="blog-header"><h1>${escapeHtml(siteTitle)} — 年別アーカイブ</h1></header>\n` +
+    `<ul class="blog-list">\n${items}\n</ul>\n` +
+    `</div>\n`
+  );
+}
+
+export function renderMonthListForYear(
+  year: string,
+  byMonth: Map<string, ArticleListEntry[]>,
+  fromRel = `archive/${year}.html`,
+): string {
+  const months = [...byMonth.keys()]
+    .filter((ym) => ym.startsWith(year))
+    .sort((a, b) => b.localeCompare(a));
+  const items = months
+    .map((ym) => {
+      const count = byMonth.get(ym)!.length;
+      const label = ym.slice(5);
+      const href = relLinkFrom(fromRel, `archive/${ym}.html`);
+      return `<li><a href="${escapeHtml(href)}">${escapeHtml(year)}年${escapeHtml(label)}月</a> (${count})</li>`;
+    })
+    .join("\n");
+  const backHref = relLinkFrom(fromRel, "archive/index.html");
+  return (
+    `<div class="blog-index">\n` +
+    `<header class="blog-header"><h1>${escapeHtml(year)}年</h1></header>\n` +
+    `<ul class="blog-list">\n${items}\n</ul>\n` +
+    `<p><a href="${escapeHtml(backHref)}">← 年別アーカイブ</a></p>\n` +
+    `</div>\n`
+  );
+}
+
+export { renderBlogIndexBody };