@sorane/core 0.2.3 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sorane/core",
-  "version": "0.2.3",
+  "version": "0.2.7",
   "description": "OKF-native static site build engine for sorane",
   "type": "module",
   "license": "MIT",
@@ -25,9 +25,9 @@
   },
   "dependencies": {
     "@mermaid-js/mermaid-cli": "~11.15.0",
-    "@sorane/font": "0.2.0",
-    "@sorane/okf": "0.2.1",
-    "@sorane/search": "0.2.1",
+    "@sorane/font": "0.2.7",
+    "@sorane/okf": "0.2.7",
+    "@sorane/search": "0.2.7",
     "mermaid": "~11.15.0",
     "rehype-autolink-headings": "^7.1.0",
     "rehype-raw": "^7.0.0",

package/src/build.ts

@@ -3,6 +3,8 @@ import { emitSearchAssets } from "@sorane/search";
 import {
   parseConcept,
   buildBundleEntries,
+  isBuildableContentType,
+  resolveEffectiveType,
   type ParsedConcept,
 } from "@sorane/okf";
 import {
@@ -23,7 +25,9 @@ import {
   parseAiDisclosure,
   resolveAiDisclosureFlags,
 } from "./ai-disclosure.ts";
-import { buildCatalogJsonLd } from "./catalog.ts";
+import { buildCatalogJsonLd, buildDatasetPageJsonLd } from "./catalog.ts";
+import { resolveCatalogCreativeWorkType } from "./creative-work-type.ts";
+import { renderDatasetPageBody } from "./dataset-page.ts";
 import {
   DEFAULT_DIAGRAMS_CONFIG,
   mergeConfig,
@@ -31,7 +35,7 @@ import {
   type SoraneConfig,
 } from "./config.ts";
 import {
-  buildBlogPostingJsonLd,
+  buildCreativeWorkJsonLd,
   extractDescription,
   renderArticleBodyWithMetaForConfig,
   renderBlogIndexBody,
@@ -152,7 +156,7 @@ function isSystemPage(concept: ParsedConcept["concept"]): boolean {
 
 function isBlogArticle(concept: ParsedConcept["concept"], relPath: string): boolean {
   return (
-    concept.type === "article" &&
+    resolveEffectiveType(concept.type, concept.profile) === "article" &&
     !isSystemPage(concept) &&
     !isNotFoundSource(relPath) &&
     !isSearchView(concept.frontmatter) &&
@@ -478,21 +482,23 @@ export async function runBuild(opts: BuildOptions): Promise<BuildResult> {
   );
   const staticDirName = config.build.static_dir ?? "static";
 
-  // --- Phase A: articles（SSG の核）---
+  // --- Phase A: content pages（article, dataset, reference, glossary, faq）---
   for (const p of parsed) {
     if (
-      p.concept.type !== "article" ||
+      !isBuildableContentType(p.concept.type, p.concept.profile) ||
       isSystemPage(p.concept) ||
       isNotFoundSource(p.relPath)
     ) {
       continue;
     }
 
+    const effectiveType = resolveEffectiveType(p.concept.type, p.concept.profile);
     const slug = slugFromRel(p.relPath);
     const outRel = resolvePermalink(config.build.permalink, slug, p.concept.timestamp);
     const depth = outRel.replace(/\\/g, "/").split("/").length - 1;
     const rootPrefix = depth > 0 ? "../".repeat(depth) : "./";
-    const isSearch = isSearchView(p.concept.frontmatter);
+    const isSearch =
+      effectiveType === "article" && isSearchView(p.concept.frontmatter);
     const isDocsPage = docsMode && docsHrefSet.has(outRel);
     const nav = isSearch
       ? undefined
@@ -514,7 +520,18 @@ export async function runBuild(opts: BuildOptions): Promise<BuildResult> {
         : "";
     let pageDiagrams = emptyDiagramMeta();
     let bodyHtml: string;
-    if (isSearch) {
+    const canonicalUrl = baseUrl.length > 0 ? `${baseUrl}/${outRel}` : undefined;
+    if (effectiveType === "dataset") {
+      const section = await renderBodySectionForConfig(
+        p.concept.body,
+        bodySectionOpts(rootPrefix),
+      );
+      pageDiagrams = section.diagrams;
+      bodyHtml = renderDatasetPageBody(p.concept, section.html, {
+        pageUrl: canonicalUrl ?? outRel,
+        baseUrl,
+      });
+    } else if (isSearch) {
       const searchIntro = p.concept.body.trim()
         ? await renderBodySectionForConfig(p.concept.body, bodySectionOpts(rootPrefix))
         : undefined;
@@ -552,7 +569,6 @@ export async function runBuild(opts: BuildOptions): Promise<BuildResult> {
 
     const updated = frontmatterString(p.concept.frontmatter, "updated");
     const author = frontmatterString(p.concept.frontmatter, "author");
-    const canonicalUrl = baseUrl.length > 0 ? `${baseUrl}/${outRel}` : undefined;
     const pageImageRefs = collectMarkdownImageRefs({
       body: p.concept.body,
       sourceMdRel: p.relPath,
@@ -572,19 +588,26 @@ export async function runBuild(opts: BuildOptions): Promise<BuildResult> {
 
     const jsonLd = isSearch
       ? ""
-      : buildBlogPostingJsonLd({
-          title: p.concept.title,
-          description: p.concept.description ?? extractDescription(p.concept.body) ?? undefined,
-          url: canonicalUrl ?? outRel,
-          datePublished: p.concept.timestamp,
-          dateModified: updated ?? p.concept.timestamp,
-          author,
-          siteTitle: config.site.title,
-          lang: config.site.lang,
-          aiDisclosure:
-            pageAiFlags.jsonLd && aiDisclosure ? aiDisclosure : undefined,
-          associatedMedia: associatedMedia.length > 0 ? associatedMedia : undefined,
-        });
+      : effectiveType === "dataset"
+        ? buildDatasetPageJsonLd(
+            { slug, url: canonicalUrl ?? outRel, concept: p.concept },
+            pageAiFlags.jsonLd,
+          )
+        : buildCreativeWorkJsonLd({
+            workType: resolveCatalogCreativeWorkType(p.concept, docsMode),
+            title: p.concept.title,
+            description:
+              p.concept.description ?? extractDescription(p.concept.body) ?? undefined,
+            url: canonicalUrl ?? outRel,
+            datePublished: p.concept.timestamp,
+            dateModified: updated ?? p.concept.timestamp,
+            author,
+            siteTitle: config.site.title,
+            lang: config.site.lang,
+            aiDisclosure:
+              pageAiFlags.jsonLd && aiDisclosure ? aiDisclosure : undefined,
+            associatedMedia: associatedMedia.length > 0 ? associatedMedia : undefined,
+          });
 
     const fontCss = await fontCssFor(p.concept, rootPrefix, bodyHtml);
     const headerSearch = headerSearchFor(rootPrefix, {
@@ -963,6 +986,7 @@ export async function runBuild(opts: BuildOptions): Promise<BuildResult> {
     join(outDir, "catalog.jsonld"),
     buildCatalogJsonLd(catalogInputs, config.site.title, baseUrl, {
       machineReadable: siteAiFlags.machineReadable,
+      docsMode,
     }),
     "utf8",
   );

package/src/catalog.ts

@@ -1,5 +1,17 @@
 import type { OkfConcept } from "@sorane/okf";
+import { resolveEffectiveType } from "@sorane/okf";
 import { parseAiDisclosure } from "./ai-disclosure.ts";
+import {
+  isDatasetCatalogEntry,
+  resolveCatalogCreativeWorkType,
+} from "./creative-work-type.ts";
+import {
+  parseDistributions,
+  parsePublisher,
+  resolveDistributionUrl,
+  resolveLicenseUrl,
+  resolveMediaType,
+} from "./open-data.ts";
 
 export interface CatalogEntry {
   readonly slug: string;
@@ -7,46 +19,151 @@ export interface CatalogEntry {
   readonly concept: OkfConcept;
 }
 
+export interface CatalogPublisher {
+  readonly name: string;
+  readonly url?: string;
+}
+
+export interface BuildCatalogOptions {
+  readonly machineReadable?: boolean;
+  readonly docsMode?: boolean;
+  readonly publisher?: CatalogPublisher;
+}
+
+function markdownDistribution(pageUrl: string): Record<string, unknown> {
+  return {
+    "@type": "DataDownload",
+    encodingFormat: "text/markdown",
+    contentUrl: pageUrl.replace(/\.html$/, ".md"),
+  };
+}
+
+function applyAiDisclosure(
+  target: Record<string, unknown>,
+  concept: OkfConcept,
+  machineReadable: boolean,
+): void {
+  const disclosure = machineReadable ? parseAiDisclosure(concept.frontmatter) : null;
+  if (!disclosure) return;
+  target.digitalSourceType = disclosure.digitalSourceType;
+  if (disclosure.systems?.length) {
+    const kw = (target.keywords as string[] | undefined) ?? [];
+    target.keywords = [
+      ...kw,
+      ...disclosure.systems.map((s) => `ai-system:${s.name}`),
+    ];
+  }
+}
+
+function buildDatasetNode(
+  e: CatalogEntry,
+  machineReadable: boolean,
+): Record<string, unknown> {
+  const concept = e.concept;
+  const dataset: Record<string, unknown> = {
+    "@type": "Dataset",
+    "@id": e.url,
+    name: concept.title,
+    keywords: [resolveEffectiveType(concept.type, concept.profile), ...(concept.tags ?? [])],
+  };
+  if (concept.description) dataset.description = concept.description;
+  if (concept.timestamp) dataset.dateModified = concept.timestamp;
+  if (concept.resource) dataset.url = concept.resource;
+
+  const identifier = concept.frontmatter.identifier;
+  if (typeof identifier === "string" && identifier.length > 0) {
+    dataset.identifier = identifier;
+  }
+  const language = concept.frontmatter.language;
+  if (typeof language === "string" && language.length > 0) {
+    dataset.inLanguage = language;
+  }
+  const theme = concept.frontmatter.theme;
+  if (typeof theme === "string" && theme.length > 0) {
+    const kw = (dataset.keywords as string[]) ?? [];
+    dataset.keywords = [...kw, `theme:${theme}`];
+  }
+
+  const licenseRaw = concept.frontmatter.license;
+  if (typeof licenseRaw === "string" && licenseRaw.length > 0) {
+    dataset.license = resolveLicenseUrl(licenseRaw);
+  }
+
+  const publisher = parsePublisher(concept.frontmatter.publisher);
+  if (publisher) {
+    const org: Record<string, unknown> = {
+      "@type": "Organization",
+      name: publisher.name,
+    };
+    if (publisher.url) org.url = publisher.url;
+    dataset.publisher = org;
+  }
+
+  const distributions = parseDistributions(concept.frontmatter.distributions);
+  const downloads: Record<string, unknown>[] = distributions.map((d) => {
+    const contentUrl = resolveDistributionUrl(d.accessURL, "", e.url);
+    const node: Record<string, unknown> = {
+      "@type": "DataDownload",
+      name: d.title,
+      encodingFormat: resolveMediaType(d.format),
+      contentUrl,
+    };
+    if (d.byteSize !== undefined) node.contentSize = d.byteSize;
+    return node;
+  });
+  downloads.push(markdownDistribution(e.url));
+  dataset.distribution = downloads;
+
+  applyAiDisclosure(dataset, concept, machineReadable);
+  return dataset;
+}
+
+function buildCreativeWorkNode(
+  e: CatalogEntry,
+  docsMode: boolean,
+  machineReadable: boolean,
+): Record<string, unknown> {
+  const workType = resolveCatalogCreativeWorkType(e.concept, docsMode);
+  const node: Record<string, unknown> = {
+    "@type": workType,
+    "@id": e.url,
+    name: e.concept.title,
+    keywords: [
+      resolveEffectiveType(e.concept.type, e.concept.profile),
+      ...(e.concept.tags ?? []),
+    ],
+    distribution: [markdownDistribution(e.url)],
+  };
+  if (e.concept.description) node.description = e.concept.description;
+  if (e.concept.timestamp) node.dateModified = e.concept.timestamp;
+  if (e.concept.resource) node.url = e.concept.resource;
+  applyAiDisclosure(node, e.concept, machineReadable);
+  return node;
+}
+
 export function buildCatalogJsonLd(
   entries: readonly CatalogEntry[],
   siteTitle: string,
   baseUrl: string,
-  opts?: { readonly machineReadable?: boolean },
+  opts?: BuildCatalogOptions,
 ): string {
   const machineReadable = opts?.machineReadable !== false;
-  const graph = entries.map((e) => {
-    const dataset: Record<string, unknown> = {
-      "@type": "Dataset",
-      "@id": e.url,
-      name: e.concept.title,
-      keywords: [e.concept.type, ...(e.concept.tags ?? [])],
-      distribution: [
-        {
-          "@type": "DataDownload",
-          encodingFormat: "text/markdown",
-          contentUrl: `${e.url.replace(/\.html$/, ".md")}`,
-        },
-      ],
-    };
-    if (e.concept.description) dataset.description = e.concept.description;
-    if (e.concept.timestamp) dataset.dateModified = e.concept.timestamp;
-    const disclosure = machineReadable
-      ? parseAiDisclosure(e.concept.frontmatter)
-      : null;
-    if (disclosure) {
-      dataset.digitalSourceType = disclosure.digitalSourceType;
-      if (disclosure.systems?.length) {
-        const kw = dataset.keywords as string[];
-        dataset.keywords = [
-          ...kw,
-          ...disclosure.systems.map((s) => `ai-system:${s.name}`),
-        ];
-      }
+  const docsMode = opts?.docsMode === true;
+
+  const datasets: Record<string, unknown>[] = [];
+  const hasPart: Record<string, unknown>[] = [];
+
+  for (const e of entries) {
+    if (isDatasetCatalogEntry(e.concept)) {
+      datasets.push(buildDatasetNode(e, machineReadable));
+    } else {
+      const effective = resolveEffectiveType(e.concept.type, e.concept.profile);
+      if (effective === "index") continue;
+      hasPart.push(buildCreativeWorkNode(e, docsMode, machineReadable));
     }
-    return dataset;
-  });
+  }
 
-  const catalog = {
+  const catalog: Record<string, unknown> = {
     "@context": {
       "@vocab": "https://schema.org/",
       dcat: "http://www.w3.org/ns/dcat#",
@@ -54,8 +171,29 @@ export function buildCatalogJsonLd(
     "@type": "DataCatalog",
     name: siteTitle,
     url: baseUrl.length > 0 ? baseUrl : undefined,
-    dataset: graph,
   };
 
+  if (opts?.publisher) {
+    const org: Record<string, unknown> = {
+      "@type": "Organization",
+      name: opts.publisher.name,
+    };
+    if (opts.publisher.url) org.url = opts.publisher.url;
+    catalog.publisher = org;
+  }
+
+  if (datasets.length > 0) catalog.dataset = datasets;
+  if (hasPart.length > 0) catalog.hasPart = hasPart;
+
   return JSON.stringify(catalog, null, 2) + "\n";
+}
+
+/** Per-page Dataset JSON-LD (`<script>` HTML). */
+export function buildDatasetPageJsonLd(
+  entry: CatalogEntry,
+  machineReadable = true,
+): string {
+  const node = buildDatasetNode(entry, machineReadable);
+  node["@context"] = "https://schema.org";
+  return `<script type="application/ld+json">${JSON.stringify(node)}</script>`;
 }

package/src/creative-work-type.ts

@@ -0,0 +1,28 @@
+import type { OkfConcept } from "@sorane/okf";
+import { resolveEffectiveType } from "@sorane/okf";
+
+export type CatalogCreativeWorkType =
+  | "BlogPosting"
+  | "TechArticle"
+  | "FAQPage"
+  | "DefinedTermSet";
+
+export function resolveCatalogCreativeWorkType(
+  concept: OkfConcept,
+  docsMode: boolean,
+): CatalogCreativeWorkType {
+  const effective = resolveEffectiveType(concept.type, concept.profile);
+  if (effective === "reference") return "TechArticle";
+  if (effective === "faq") return "FAQPage";
+  if (effective === "glossary") return "DefinedTermSet";
+
+  const override = concept.frontmatter.creativeWorkType;
+  if (override === "TechArticle" || override === "BlogPosting") {
+    return override;
+  }
+  return docsMode ? "TechArticle" : "BlogPosting";
+}
+
+export function isDatasetCatalogEntry(concept: OkfConcept): boolean {
+  return resolveEffectiveType(concept.type, concept.profile) === "dataset";
+}

package/src/dataset-page.ts

@@ -0,0 +1,102 @@
+import type { OkfConcept } from "@sorane/okf";
+import {
+  parseDistributions,
+  parsePublisher,
+  resolveDistributionUrl,
+  resolveLicenseUrl,
+  type DistributionRef,
+} from "./open-data.ts";
+import { escapeHtml } from "./render.ts";
+
+function formatBytes(n: number): string {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+function distributionRow(
+  dist: DistributionRef,
+  pageUrl: string,
+  baseUrl: string,
+): string {
+  const href = resolveDistributionUrl(dist.accessURL, baseUrl, pageUrl);
+  const size =
+    dist.byteSize !== undefined ? ` <span class="dataset-size">(${formatBytes(dist.byteSize)})</span>` : "";
+  const checksum = dist.checksum
+    ? `<div class="dataset-checksum"><code>${escapeHtml(dist.checksum)}</code></div>`
+    : "";
+  return (
+    `<tr>` +
+    `<td>${escapeHtml(dist.title)}</td>` +
+    `<td><code>${escapeHtml(dist.format)}</code></td>` +
+    `<td><a href="${escapeHtml(href)}">${escapeHtml(href)}</a>${size}${checksum}</td>` +
+    `</tr>`
+  );
+}
+
+/** Dataset landing: metadata block + distribution table + rendered body. */
+export function renderDatasetPageBody(
+  concept: OkfConcept,
+  bodyHtml: string,
+  opts: { readonly pageUrl: string; readonly baseUrl: string },
+): string {
+  const licenseRaw = concept.frontmatter.license;
+  const license =
+    typeof licenseRaw === "string" && licenseRaw.length > 0
+      ? resolveLicenseUrl(licenseRaw)
+      : undefined;
+  const publisher = parsePublisher(concept.frontmatter.publisher);
+  const distributions = parseDistributions(concept.frontmatter.distributions);
+  const identifier = concept.frontmatter.identifier;
+  const theme = concept.frontmatter.theme;
+  const language = concept.frontmatter.language;
+
+  const meta: string[] = [];
+  if (license) {
+    meta.push(
+      `<p class="dataset-meta"><strong>License:</strong> <a href="${escapeHtml(license)}">${escapeHtml(String(licenseRaw))}</a></p>`,
+    );
+  }
+  if (publisher) {
+    const pub =
+      publisher.url !== undefined
+        ? `<a href="${escapeHtml(publisher.url)}">${escapeHtml(publisher.name)}</a>`
+        : escapeHtml(publisher.name);
+    meta.push(`<p class="dataset-meta"><strong>Publisher:</strong> ${pub}</p>`);
+  }
+  if (typeof identifier === "string" && identifier.length > 0) {
+    meta.push(
+      `<p class="dataset-meta"><strong>Identifier:</strong> <code>${escapeHtml(identifier)}</code></p>`,
+    );
+  }
+  if (typeof theme === "string" && theme.length > 0) {
+    meta.push(`<p class="dataset-meta"><strong>Theme:</strong> <code>${escapeHtml(theme)}</code></p>`);
+  }
+  if (typeof language === "string" && language.length > 0) {
+    meta.push(`<p class="dataset-meta"><strong>Language:</strong> <code>${escapeHtml(language)}</code></p>`);
+  }
+  if (concept.resource) {
+    meta.push(
+      `<p class="dataset-meta"><strong>Resource:</strong> <a href="${escapeHtml(concept.resource)}">${escapeHtml(concept.resource)}</a></p>`,
+    );
+  }
+
+  const table =
+    distributions.length > 0
+      ? `<section class="dataset-distributions" aria-labelledby="dataset-distributions-heading">` +
+        `<h2 id="dataset-distributions-heading">Distributions</h2>` +
+        `<table class="dataset-table"><thead><tr><th>Name</th><th>Format</th><th>Access</th></tr></thead><tbody>` +
+        distributions
+          .map((d) => distributionRow(d, opts.pageUrl, opts.baseUrl))
+          .join("") +
+        `</tbody></table></section>`
+      : "";
+
+  return (
+    `<div class="dataset-landing">` +
+    meta.join("") +
+    table +
+    `</div>` +
+    `<div class="dataset-body">${bodyHtml}</div>`
+  );
+}

package/src/migrate.ts

@@ -10,7 +10,7 @@ function slugFromPath(filePath: string): string {
   return base.replace(/\.md$/i, "");
 }
 
-const SUPPORTED_BUMP_PROFILES = new Set(["0.1", "0.2"]);
+const SUPPORTED_BUMP_PROFILES = new Set(["0.1", "0.2", "0.3"]);
 
 export interface MigrateToOkfOptions {
   readonly bumpProfile?: string;
@@ -54,7 +54,7 @@ export function parseBumpProfileArg(argv: readonly string[]): string | undefined
   if (i < 0 || i + 1 >= argv.length) return undefined;
   const version = argv[i + 1]!.trim();
   if (!SUPPORTED_BUMP_PROFILES.has(version)) {
-    throw new Error(`unsupported --bump-profile version: ${version} (supported: 0.1, 0.2)`);
+    throw new Error(`unsupported --bump-profile version: ${version} (supported: 0.1, 0.2, 0.3)`);
   }
   return version;
 }

package/src/open-data.ts

@@ -0,0 +1,124 @@
+export interface PublisherRef {
+  readonly name: string;
+  readonly url?: string;
+  readonly email?: string;
+}
+
+export interface DistributionRef {
+  readonly title: string;
+  readonly format: string;
+  readonly accessURL: string;
+  readonly downloadURL?: string;
+  readonly byteSize?: number;
+  readonly checksum?: string;
+}
+
+const SPDX_LICENSE_URL: Record<string, string> = {
+  "CC-BY-4.0": "https://creativecommons.org/licenses/by/4.0/",
+  "CC-BY-3.0": "https://creativecommons.org/licenses/by/3.0/",
+  "CC0-1.0": "https://creativecommons.org/publicdomain/zero/1.0/",
+  "EUPL-1.2": "https://interoperable.europe.eu/collection/eupl/eupl-text-eupl-12",
+};
+
+const FORMAT_MEDIA: Record<string, string> = {
+  csv: "text/csv",
+  tsv: "text/tab-separated-values",
+  json: "application/json",
+  jsonld: "application/ld+json",
+  xml: "application/xml",
+  pdf: "application/pdf",
+  md: "text/markdown",
+  html: "text/html",
+  parquet: "application/vnd.apache.parquet",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+};
+
+export function resolveLicenseUrl(license: string): string {
+  const trimmed = license.trim();
+  if (/^https?:\/\//i.test(trimmed)) return trimmed;
+  return SPDX_LICENSE_URL[trimmed] ?? trimmed;
+}
+
+export function resolveMediaType(format: string): string {
+  const key = format.trim().toLowerCase();
+  if (FORMAT_MEDIA[key]) return FORMAT_MEDIA[key]!;
+  if (key.includes("/")) return key;
+  return key;
+}
+
+export function parsePublisher(
+  raw: unknown,
+): PublisherRef | undefined {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    return undefined;
+  }
+  const name = (raw as { name?: unknown }).name;
+  if (typeof name !== "string" || name.length === 0) return undefined;
+  const url = (raw as { url?: unknown }).url;
+  const email = (raw as { email?: unknown }).email;
+  return {
+    name,
+    url: typeof url === "string" && url.length > 0 ? url : undefined,
+    email: typeof email === "string" && email.length > 0 ? email : undefined,
+  };
+}
+
+export function parseDistributions(
+  raw: unknown,
+): readonly DistributionRef[] {
+  if (!Array.isArray(raw)) return [];
+  const out: DistributionRef[] = [];
+  for (const item of raw) {
+    if (item === null || typeof item !== "object" || Array.isArray(item)) continue;
+    const title = (item as { title?: unknown }).title;
+    const format = (item as { format?: unknown }).format;
+    const accessURL = (item as { accessURL?: unknown }).accessURL;
+    if (
+      typeof title !== "string" ||
+      title.length === 0 ||
+      typeof format !== "string" ||
+      format.length === 0 ||
+      typeof accessURL !== "string" ||
+      accessURL.length === 0
+    ) {
+      continue;
+    }
+    const downloadURL = (item as { downloadURL?: unknown }).downloadURL;
+    const byteSize = (item as { byteSize?: unknown }).byteSize;
+    const checksum = (item as { checksum?: unknown }).checksum;
+    out.push({
+      title,
+      format,
+      accessURL,
+      downloadURL:
+        typeof downloadURL === "string" && downloadURL.length > 0
+          ? downloadURL
+          : undefined,
+      byteSize:
+        typeof byteSize === "number" && Number.isFinite(byteSize) && byteSize >= 0
+          ? byteSize
+          : undefined,
+      checksum:
+        typeof checksum === "string" && checksum.length > 0 ? checksum : undefined,
+    });
+  }
+  return out;
+}
+
+/** Resolve distribution URL against site base (absolute URLs unchanged). */
+export function resolveDistributionUrl(
+  accessURL: string,
+  baseUrl: string,
+  pageUrl: string,
+): string {
+  const trimmed = accessURL.trim();
+  if (/^https?:\/\//i.test(trimmed)) return trimmed;
+  if (trimmed.startsWith("/")) {
+    return baseUrl.length > 0 ? `${baseUrl}${trimmed}` : trimmed;
+  }
+  try {
+    return new URL(trimmed, pageUrl).href;
+  } catch {
+    return trimmed;
+  }
+}

package/src/site-meta.ts

@@ -110,7 +110,7 @@ export function buildLlmsTxt(opts: LlmsTxtOptions): string {
     "## Machine-readable",
     "",
     `- [OKF bundle](${abs("okf/bundle.tar.gz")}): all concepts as {type}/{slug}.md`,
-    `- [DCAT catalog](${abs("catalog.jsonld")})`,
+    `- [Site catalog](${abs("catalog.jsonld")}): open datasets in \`dataset[]\`; other pages in \`hasPart[]\``,
     `- [Sitemap](${abs("sitemap.xml")})`,
   ];
   if (opts.diagramsEnabled) {

package/src/ssg.ts

@@ -334,7 +334,14 @@ function articleNavHtml(nav?: ArticleNav): string {
   return `<nav class="article-nav" aria-label="記事">${parts.join(" · ")}</nav>`;
 }
 
-export function buildBlogPostingJsonLd(opts: {
+export type PageCreativeWorkType =
+  | "BlogPosting"
+  | "TechArticle"
+  | "FAQPage"
+  | "DefinedTermSet";
+
+export function buildCreativeWorkJsonLd(opts: {
+  workType: PageCreativeWorkType;
   title: string;
   description?: string;
   url: string;
@@ -346,13 +353,19 @@ export function buildBlogPostingJsonLd(opts: {
   aiDisclosure?: AiDisclosure;
   associatedMedia?: readonly AssociatedMediaItem[];
 }): string {
+  const isPartOf =
+    opts.workType === "BlogPosting"
+      ? { "@type": "Blog", name: opts.siteTitle }
+      : { "@type": "WebSite", name: opts.siteTitle };
+
   const data: Record<string, unknown> = {
     "@context": "https://schema.org",
-    "@type": "BlogPosting",
+    "@type": opts.workType,
     headline: opts.title,
+    name: opts.title,
     url: opts.url,
     inLanguage: opts.lang,
-    isPartOf: { "@type": "Blog", name: opts.siteTitle },
+    isPartOf,
   };
   if (opts.description) data.description = opts.description;
   if (opts.datePublished) data.datePublished = opts.datePublished;
@@ -368,6 +381,22 @@ export function buildBlogPostingJsonLd(opts: {
   return `<script type="application/ld+json">${JSON.stringify(data)}</script>`;
 }
 
+/** @deprecated Use buildCreativeWorkJsonLd({ workType: "BlogPosting", ... }) */
+export function buildBlogPostingJsonLd(opts: {
+  title: string;
+  description?: string;
+  url: string;
+  datePublished?: string;
+  dateModified?: string;
+  author?: string;
+  siteTitle: string;
+  lang: string;
+  aiDisclosure?: AiDisclosure;
+  associatedMedia?: readonly AssociatedMediaItem[];
+}): string {
+  return buildCreativeWorkJsonLd({ ...opts, workType: "BlogPosting" });
+}
+
 const SERIF_FONT_STYLES = new Set(["GJM", "serif", "mincho"]);
 
 /** frontmatter の font スタイルが明朝指定なら class を返す。 */