structural-codes-viewer 0.1.0-alpha.1

package/package-dist/corpusData.d.ts

@@ -0,0 +1,235 @@
+export type DocumentId = "ntc2018" | "circ2019";
+export type ViewerMode = "ntc" | "circ" | "combined";
+export interface Evidence {
+    sourceId: string;
+    pdfPage: number;
+    printedPage: string | null;
+    region: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    transformations?: Array<{
+        operation: string;
+        note: string;
+    }>;
+    rawSha256: string;
+    normalizedSha256: string;
+}
+export interface CorpusBlock {
+    blockId: string;
+    kind: string;
+    origin: string;
+    text?: {
+        raw: string;
+        normalized: string;
+        normalizationVersion: string;
+        inline?: Array<{
+            kind: "text";
+            value: string;
+        } | {
+            kind: "math";
+            value: string;
+            latex: string;
+        }>;
+    };
+    assetId?: string;
+    evidence?: Evidence;
+}
+export interface FormulaAsset {
+    id: string;
+    officialNumber: string | null;
+    pdfPage: number;
+    latex: string;
+}
+export interface TableCell {
+    text: string;
+    latex?: string;
+    colSpan?: number;
+    rowSpan?: number;
+}
+export interface TableAsset {
+    id: string;
+    officialNumber: string | null;
+    pdfPage: number;
+    caption: string | null;
+    headers: TableCell[][];
+    rows: TableCell[][];
+    notes: string[];
+}
+export interface FigureAsset {
+    id: string;
+    officialNumber: string;
+    pdfPage: number;
+    caption: string;
+    alt: string;
+    imagePath: string;
+    region?: {
+        width: number;
+        height: number;
+    };
+}
+export interface AssetBundle {
+    formulas: Record<string, FormulaAsset>;
+    tables: Record<string, TableAsset>;
+    figures: Record<string, FigureAsset>;
+}
+export interface OpenIssue {
+    issueId: string;
+    type: string;
+    severity: "blocking" | "warning" | "info";
+    note: string;
+}
+export interface Relation {
+    relationId: string;
+    type: string;
+    targetUnitId: string;
+    basis: string;
+    rationale: string;
+    review: {
+        status: string;
+    };
+}
+export interface CorpusUnit {
+    id: string;
+    document: DocumentId;
+    kind: string;
+    numbering: {
+        official: string;
+        sortKey: string;
+    };
+    title: string;
+    hierarchy: {
+        parentId: string | null;
+        ancestorIds: string[];
+        position: number;
+    };
+    validity: {
+        from: string | null;
+        to: string | null;
+        status: string;
+        asOf: string;
+    };
+    blocks: CorpusBlock[];
+    relations: Relation[];
+    workflow: {
+        status: string;
+        openIssues: OpenIssue[];
+    };
+}
+export interface UnitSummary {
+    id: string;
+    document: DocumentId;
+    kind: string;
+    numbering: {
+        official: string;
+        sortKey: string;
+    };
+    title: string;
+    hierarchy: CorpusUnit["hierarchy"];
+    validity: CorpusUnit["validity"];
+    workflowStatus: string;
+    openIssueCount: number;
+    blockingIssueCount: number;
+    chunkPath: string;
+}
+export interface DocumentMetadata {
+    shortLabel: string;
+    label: string;
+    indexPath: string;
+    units: number;
+    blocks: number;
+    sourceId: string;
+    sourceUrl: string;
+    publicationUrl: string;
+    localSourcePath: string;
+    sourceSha256: string;
+    pages: {
+        from: number;
+        to: number;
+    };
+}
+export interface CorpusManifest {
+    formatVersion: 2;
+    generatedAt: string;
+    structuralCodesVersion: string;
+    schemaVersion: string;
+    assetSchemaVersion: string;
+    status: string;
+    disclaimer: string;
+    corpusFingerprintSha256: string;
+    generatedArtifactFingerprintSha256: string;
+    stats: {
+        units: number;
+        blocks: number;
+        explicitRelations: number;
+        proposedRelations: number;
+        suggestedRelationDiagnostics: number;
+        reviewedUnits: number;
+        assetUnits: number;
+        formulas: number;
+        tables: number;
+        figures: number;
+        chunks: number;
+    };
+    documents: Record<DocumentId, DocumentMetadata>;
+    relationsPath: string;
+    relationDiagnosticsPath: string;
+    searchIndexPath: string;
+    chunks: Array<{
+        path: string;
+        document: DocumentId;
+        key: string;
+        units: number;
+        bytes: number;
+        sha256: string;
+        contentFingerprintSha256: string;
+    }>;
+}
+export interface DocumentIndex {
+    formatVersion: 2;
+    structuralCodesVersion: string;
+    document: DocumentId;
+    units: UnitSummary[];
+}
+export interface CorpusChunk {
+    formatVersion: 2;
+    structuralCodesVersion: string;
+    schemaVersion: string;
+    document: DocumentId;
+    key: string;
+    contentFingerprintSha256: string;
+    units: CorpusUnit[];
+    assets: AssetBundle;
+}
+export interface RelationEdge extends Relation {
+    sourceUnitId: string;
+    sourceDocument: DocumentId;
+    sourceChunkPath: string;
+    targetChunkPath: string | null;
+}
+export interface RelationsIndex {
+    formatVersion: 2;
+    sourceOfTruth: "explicit-corpus-relations";
+    inferredRelationsIncluded: false;
+    relations: RelationEdge[];
+}
+export interface SearchIndex {
+    formatVersion: 2;
+    units: Array<{
+        id: string;
+        document: DocumentId;
+        numbering: string;
+        title: string;
+        chunkPath: string;
+        text: string;
+    }>;
+}
+export declare function resolveDataPath(path: string, dataBaseUrl?: string): string;
+export declare function documentForMode(mode: ViewerMode): DocumentId;
+export declare function loadManifest(dataBaseUrl?: string): Promise<CorpusManifest>;
+export declare function loadDocumentIndex(manifest: CorpusManifest, document: DocumentId, dataBaseUrl?: string): Promise<DocumentIndex>;
+export declare function loadChunk(path: string, dataBaseUrl?: string): Promise<CorpusChunk>;
+export declare function loadRelations(manifest: CorpusManifest, dataBaseUrl?: string): Promise<RelationsIndex>;
+export declare function loadSearchIndex(manifest: CorpusManifest, dataBaseUrl?: string): Promise<SearchIndex>;

package/package-dist/corpusData.js

@@ -0,0 +1,40 @@
+const jsonCache = new Map();
+function basePath(dataBaseUrl) {
+    return dataBaseUrl.replace(/\/+$/u, "");
+}
+export function resolveDataPath(path, dataBaseUrl = "/data/codes") {
+    if (dataBaseUrl === "/data/codes" || dataBaseUrl === "")
+        return path;
+    return `${basePath(dataBaseUrl)}/${path.replace(/^\/data\/codes\/?/u, "")}`;
+}
+async function fetchJson(path) {
+    let pending = jsonCache.get(path);
+    if (!pending) {
+        pending = fetch(path).then(async (response) => {
+            if (!response.ok)
+                throw new Error(`${path}: HTTP ${response.status}`);
+            return response.json();
+        });
+        jsonCache.set(path, pending);
+    }
+    return pending;
+}
+export function documentForMode(mode) {
+    return mode === "circ" ? "circ2019" : "ntc2018";
+}
+export function loadManifest(dataBaseUrl = "/data/codes") {
+    return fetchJson(resolveDataPath("/data/codes/manifest.json", dataBaseUrl));
+}
+export function loadDocumentIndex(manifest, document, dataBaseUrl = "/data/codes") {
+    return fetchJson(resolveDataPath(manifest.documents[document].indexPath, dataBaseUrl));
+}
+export function loadChunk(path, dataBaseUrl = "/data/codes") {
+    return fetchJson(resolveDataPath(path, dataBaseUrl));
+}
+export function loadRelations(manifest, dataBaseUrl = "/data/codes") {
+    return fetchJson(resolveDataPath(manifest.relationsPath, dataBaseUrl));
+}
+export function loadSearchIndex(manifest, dataBaseUrl = "/data/codes") {
+    return fetchJson(resolveDataPath(manifest.searchIndexPath, dataBaseUrl));
+}
+//# sourceMappingURL=corpusData.js.map

package/package-dist/corpusData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"corpusData.js","sourceRoot":"","sources":["../shared/corpusData.ts"],"names":[],"mappings":"AA2JA,MAAM,SAAS,GAAG,IAAI,GAAG,EAA4B,CAAC;AAEtD,SAAS,QAAQ,CAAC,WAAmB;IACnC,OAAO,WAAW,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;AAC1C,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,IAAY,EAAE,WAAW,GAAG,aAAa;IACvE,IAAI,WAAW,KAAK,aAAa,IAAI,WAAW,KAAK,EAAE;QAAE,OAAO,IAAI,CAAC;IACrE,OAAO,GAAG,QAAQ,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,oBAAoB,EAAE,EAAE,CAAC,EAAE,CAAC;AAC9E,CAAC;AAED,KAAK,UAAU,SAAS,CAAI,IAAY;IACtC,IAAI,OAAO,GAAG,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAClC,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE;YAC5C,IAAI,CAAC,QAAQ,CAAC,EAAE;gBAAE,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,UAAU,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;YACtE,OAAO,QAAQ,CAAC,IAAI,EAAE,CAAC;QACzB,CAAC,CAAC,CAAC;QACH,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,OAAqB,CAAC;AAC/B,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,IAAgB;IAC9C,OAAO,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC;AAClD,CAAC;AACD,MAAM,UAAU,YAAY,CAAC,WAAW,GAAG,aAAa;IACtD,OAAO,SAAS,CAAiB,eAAe,CAAC,2BAA2B,EAAE,WAAW,CAAC,CAAC,CAAC;AAC9F,CAAC;AACD,MAAM,UAAU,iBAAiB,CAAC,QAAwB,EAAE,QAAoB,EAAE,WAAW,GAAG,aAAa;IAC3G,OAAO,SAAS,CAAgB,eAAe,CAAC,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC;AACxG,CAAC;AACD,MAAM,UAAU,SAAS,CAAC,IAAY,EAAE,WAAW,GAAG,aAAa;IACjE,OAAO,SAAS,CAAc,eAAe,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC;AACpE,CAAC;AACD,MAAM,UAAU,aAAa,CAAC,QAAwB,EAAE,WAAW,GAAG,aAAa;IACjF,OAAO,SAAS,CAAiB,eAAe,CAAC,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC,CAAC;AACzF,CAAC;AACD,MAAM,UAAU,eAAe,CAAC,QAAwB,EAAE,WAAW,GAAG,aAAa;IACnF,OAAO,SAAS,CAAc,eAAe,CAAC,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC,CAAC;AACxF,CAAC"}

package/package-dist/generate-artifacts.mjs

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+import { createHash } from "node:crypto";
+import { copyFile, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const documentOrder = ["ntc2018", "circ2019"];
+const maxInitialChunkBytes = 1_500_000;
+const documentLabels = {
+  ntc2018: { shortLabel: "NTC 2018", label: "Norme Tecniche per le Costruzioni" },
+  circ2019: { shortLabel: "Circolare 7/2019", label: "Istruzioni per l’applicazione delle NTC 2018" },
+};
+
+function sha256(value) { return createHash("sha256").update(value).digest("hex"); }
+async function json(file) { return JSON.parse(await readFile(file, "utf8")); }
+async function writeJson(file, value) {
+  await mkdir(dirname(file), { recursive: true });
+  const serialized = `${JSON.stringify(value)}\n`;
+  await writeFile(file, serialized, "utf8");
+  return { bytes: Buffer.byteLength(serialized), sha256: sha256(serialized) };
+}
+function assertOutputDirectory(outputDirectory, sourceRoot) {
+  const output = resolve(outputDirectory);
+  if (output === resolve(sourceRoot)) throw new Error(`output generator coincide con il package sorgente: ${output}`);
+  if (output === resolve(dirname(sourceRoot))) throw new Error(`output generator troppo ampio: ${output}`);
+}
+async function sourceRootFor(sourcePackage) {
+  const packageUrl = await import.meta.resolve(`${sourcePackage}/package.json`);
+  return dirname(fileURLToPath(packageUrl));
+}
+async function loadUnits(corpusRoot, document) {
+  const directory = join(corpusRoot, document);
+  const files = (await readdir(directory)).filter((file) => file.endsWith(".json")).sort((left, right) => left.localeCompare(right, "it", { numeric: true }));
+  const units = await Promise.all(files.map((file) => json(join(directory, file))));
+  return units.sort((left, right) => left.numbering.sortKey.localeCompare(right.numbering.sortKey, "it", { numeric: true }));
+}
+function baseChunkKey(unit, depth = 2) {
+  const components = unit.numbering.official.replace(/^C/iu, "").split(".");
+  return components.slice(0, Math.min(depth, components.length)).join(".");
+}
+function assignChunkKeys(units) {
+  const initial = new Map();
+  for (const unit of units) {
+    const key = baseChunkKey(unit);
+    const group = initial.get(key) ?? [];
+    group.push(unit);
+    initial.set(key, group);
+  }
+  const assigned = new Map();
+  for (const [key, group] of initial) {
+    if (Buffer.byteLength(JSON.stringify(group)) <= maxInitialChunkBytes) {
+      for (const unit of group) assigned.set(unit.id, key);
+      continue;
+    }
+    for (const unit of group) {
+      const refined = baseChunkKey(unit, 3);
+      assigned.set(unit.id, refined === key ? `${key}.root` : refined);
+    }
+  }
+  return assigned;
+}
+function publicUnit(document, unit) { return { ...unit, document }; }
+function unitSummary(document, unit, chunkPath) {
+  const openIssues = unit.workflow.openIssues ?? [];
+  return { id: unit.id, document, kind: unit.kind, numbering: unit.numbering, title: unit.title, hierarchy: unit.hierarchy, validity: unit.validity, workflowStatus: unit.workflow.status, openIssueCount: openIssues.length, blockingIssueCount: openIssues.filter(({ severity }) => severity === "blocking").length, chunkPath };
+}
+
+export async function generateArtifacts({ sourcePackage = "structural-codes", outputDirectory = join(process.cwd(), "public", "data", "codes"), assetOutputDirectory = join(process.cwd(), "public", "assets") } = {}) {
+  const sourceRoot = await sourceRootFor(sourcePackage);
+  assertOutputDirectory(outputDirectory, sourceRoot);
+  assertOutputDirectory(assetOutputDirectory, sourceRoot);
+  const corpusRoot = join(sourceRoot, "corpus", "units");
+  const corpusManifestFile = join(sourceRoot, "corpus", "manifest.json");
+  const assetManifestDirectory = join(sourceRoot, "corpus", "assets");
+  const sourceRegistryFile = join(sourceRoot, "sources", "registry", "sources.v2.json");
+  const packageFile = join(sourceRoot, "package.json");
+  const legacyOutput = join(dirname(outputDirectory), "corpus.json");
+  const figureOutput = assetOutputDirectory;
+  const [corpusManifest, sourceRegistry, packageManifest] = await Promise.all([json(corpusManifestFile), json(sourceRegistryFile), json(packageFile)]);
+  const assetManifestFiles = (await readdir(assetManifestDirectory, { recursive: true })).filter((file) => file.endsWith(".json")).sort((left, right) => left.localeCompare(right, "it", { numeric: true }));
+  const assetManifests = await Promise.all(assetManifestFiles.map((file) => json(join(assetManifestDirectory, file))));
+  const assetCollections = { formulas: assetManifests.flatMap(({ formulas }) => formulas), tables: assetManifests.flatMap(({ tables }) => tables), figures: assetManifests.flatMap(({ figures }) => figures) };
+  const assetsById = Object.fromEntries(Object.entries(assetCollections).map(([kind, assets]) => [kind, new Map(assets.map((asset) => [asset.id, asset]))]));
+  const unitsByDocument = Object.fromEntries(await Promise.all(documentOrder.map(async (document) => [document, await loadUnits(corpusRoot, document)])));
+  const allUnits = documentOrder.flatMap((document) => unitsByDocument[document].map((unit) => publicUnit(document, unit)));
+  await Promise.all([rm(outputDirectory, { recursive: true, force: true }), rm(legacyOutput, { force: true }), rm(figureOutput, { recursive: true, force: true })]);
+  const chunkPathByUnit = new Map();
+  const documentIndexes = {};
+  const chunkInventory = [];
+  for (const document of documentOrder) {
+    const units = unitsByDocument[document];
+    const keys = assignChunkKeys(units);
+    const groups = new Map();
+    for (const unit of units) {
+      const key = keys.get(unit.id);
+      const chunkPath = `/data/codes/${document}/chunks/${key}.json`;
+      chunkPathByUnit.set(unit.id, chunkPath);
+      const group = groups.get(key) ?? [];
+      group.push(unit);
+      groups.set(key, group);
+    }
+    for (const [key, group] of [...groups].sort(([left], [right]) => left.localeCompare(right, "it", { numeric: true }))) {
+      const assetIds = new Set(group.flatMap((unit) => [...unit.assets.formulaIds, ...unit.assets.tableIds, ...unit.assets.figureIds, ...unit.blocks.flatMap((block) => block.assetId ? [block.assetId] : [])]));
+      const assets = Object.fromEntries(Object.entries(assetsById).map(([kind, lookup]) => [kind, Object.fromEntries([...assetIds].map((id) => lookup.get(id)).filter(Boolean).map((asset) => [asset.id, asset]))]));
+      const unitPayload = group.map((unit) => publicUnit(document, unit));
+      const contentFingerprintSha256 = sha256(JSON.stringify({ unitPayload, assets }));
+      const chunk = { formatVersion: 2, structuralCodesVersion: packageManifest.version, schemaVersion: group[0]?.schemaVersion ?? null, document, key, contentFingerprintSha256, units: unitPayload, assets };
+      const chunkFile = join(outputDirectory, document, "chunks", `${key}.json`);
+      const written = await writeJson(chunkFile, chunk);
+      chunkInventory.push({ path: `/data/codes/${relative(outputDirectory, chunkFile).replaceAll("\\", "/")}`, document, key, units: group.length, bytes: written.bytes, sha256: written.sha256, contentFingerprintSha256 });
+    }
+    const summaries = units.map((unit) => unitSummary(document, unit, chunkPathByUnit.get(unit.id)));
+    const indexPayload = { formatVersion: 2, structuralCodesVersion: packageManifest.version, document, units: summaries };
+    const indexFile = join(outputDirectory, document, "index.json");
+    const written = await writeJson(indexFile, indexPayload);
+    documentIndexes[document] = { ...documentLabels[document], indexPath: `/data/codes/${document}/index.json`, indexFingerprintSha256: written.sha256, units: summaries.length };
+  }
+  const relations = allUnits.flatMap((unit) => unit.relations.map((relation) => ({ sourceUnitId: unit.id, sourceDocument: unit.document, sourceChunkPath: chunkPathByUnit.get(unit.id), targetUnitId: relation.targetUnitId, targetChunkPath: chunkPathByUnit.get(relation.targetUnitId) ?? null, ...relation })));
+  const relationsWritten = await writeJson(join(outputDirectory, "relations.json"), { formatVersion: 2, sourceOfTruth: "explicit-corpus-relations", inferredRelationsIncluded: false, relations });
+  const ntcByNumber = new Map(unitsByDocument.ntc2018.map((unit) => [unit.numbering.official, unit]));
+  const diagnostics = unitsByDocument.circ2019.flatMap((unit) => { const candidate = ntcByNumber.get(unit.numbering.official.replace(/^C/iu, "")); if (!candidate || unit.relations.some((relation) => relation.targetUnitId === candidate.id)) return []; return [{ kind: "suggested-relation", status: "diagnostic-only-not-canonical", reason: "same-numbering", sourceUnitId: unit.id, targetUnitId: candidate.id, sourceChunkPath: chunkPathByUnit.get(unit.id), targetChunkPath: chunkPathByUnit.get(candidate.id) }]; });
+  const diagnosticsWritten = await writeJson(join(outputDirectory, "relation-diagnostics.json"), { formatVersion: 2, warning: "Suggerimenti diagnostici non revisionati: non sono usati dalla vista combinata.", suggestions: diagnostics });
+  const searchWritten = await writeJson(join(outputDirectory, "search-index.json"), { formatVersion: 2, normalization: "NFKC lowercase it-IT at query time", units: allUnits.map((unit) => ({ id: unit.id, document: unit.document, numbering: unit.numbering.official, title: unit.title, chunkPath: chunkPathByUnit.get(unit.id), text: unit.blocks.flatMap((block) => block.text?.normalized ? [block.text.normalized] : []).join(" ") })) });
+  const manifestationBySourceId = new Map(sourceRegistry.works.flatMap((work) => work.manifestations.map((manifestation) => [manifestation.sourceId, { manifestation, work }])));
+  for (const document of documentOrder) {
+    const manifestDocument = corpusManifest.documents[document];
+    const source = manifestationBySourceId.get(manifestDocument.sourceId);
+    if (!source) throw new Error(`sourceId non risolto: ${manifestDocument.sourceId}`);
+    Object.assign(documentIndexes[document], { sourceId: manifestDocument.sourceId, sourceUrl: source.manifestation.officialUrl, publicationUrl: source.work.publication.eliUri, localSourcePath: source.manifestation.localFile, sourceSha256: source.manifestation.sha256, pages: manifestDocument.pages, blocks: unitsByDocument[document].reduce((total, unit) => total + unit.blocks.filter((block) => block.text).length, 0) });
+  }
+  const reviewedStatuses = new Set(["source-checked", "double-reviewed", "published", "superseded"]);
+  const corpusFingerprintSha256 = sha256(JSON.stringify({ corpusManifest, unitsByDocument, assetManifests }));
+  const artifactFingerprintSha256 = sha256(JSON.stringify({ chunkInventory, indexes: documentIndexes, relations: relationsWritten.sha256, diagnostics: diagnosticsWritten.sha256, search: searchWritten.sha256 }));
+  const manifest = { formatVersion: 2, generatedAt: corpusManifest.asOf, structuralCodesVersion: packageManifest.version, schemaVersion: allUnits[0]?.schemaVersion ?? null, assetSchemaVersion: assetManifests[0]?.schemaVersion ?? null, status: corpusManifest.status, disclaimer: corpusManifest.disclaimer, corpusFingerprintSha256, generatedArtifactFingerprintSha256: artifactFingerprintSha256, stats: { units: allUnits.length, blocks: allUnits.reduce((total, unit) => total + unit.blocks.filter((block) => block.text).length, 0), explicitRelations: relations.length, proposedRelations: relations.filter((relation) => relation.review.status === "proposed").length, suggestedRelationDiagnostics: diagnostics.length, reviewedUnits: allUnits.filter((unit) => reviewedStatuses.has(unit.workflow.status)).length, assetUnits: allUnits.filter((unit) => unit.assets.formulaIds.length > 0 || unit.assets.tableIds.length > 0 || unit.assets.figureIds.length > 0).length, formulas: assetCollections.formulas.length, tables: assetCollections.tables.length, figures: assetCollections.figures.length, chunks: chunkInventory.length }, documents: documentIndexes, relationsPath: "/data/codes/relations.json", relationDiagnosticsPath: "/data/codes/relation-diagnostics.json", searchIndexPath: "/data/codes/search-index.json", chunks: chunkInventory };
+  const manifestWritten = await writeJson(join(outputDirectory, "manifest.json"), manifest);
+  let copiedFigureBytes = 0;
+  for (const figure of assetCollections.figures) {
+    const source = join(sourceRoot, "corpus", "assets", figure.imagePath);
+    const destination = join(figureOutput, figure.imagePath);
+    await mkdir(dirname(destination), { recursive: true });
+    await copyFile(source, destination);
+    copiedFigureBytes += (await stat(source)).size;
+  }
+  return { manifest, artifactFingerprintSha256, units: allUnits.length, chunks: chunkInventory.length, relations: relations.length, diagnostics: diagnostics.length, manifestBytes: manifestWritten.bytes, figureBytes: copiedFigureBytes };
+}
+
+if (process.argv[1] && pathToFileURL(resolve(process.argv[1])).href === import.meta.url) {
+  const args = new Map(process.argv.slice(2).flatMap((argument, index, values) => argument.startsWith("--") && values[index + 1] && !values[index + 1].startsWith("--") ? [[argument.slice(2), values[index + 1]]] : []));
+  const result = await generateArtifacts({ sourcePackage: args.get("source") ?? "structural-codes", outputDirectory: args.get("output") ?? join(process.cwd(), "public", "data", "codes"), assetOutputDirectory: args.get("assets") ?? join(process.cwd(), "public", "assets") });
+  console.log(`generate-artifacts: ${result.units} unità in ${result.chunks} chunk; ${result.relations} relazioni esplicite; artifact sha256 ${result.artifactFingerprintSha256}`);
+}

package/package-dist/styles.css

@@ -0,0 +1,182 @@
+@import "@fontsource/tinos/latin-400.css";
+@import "@fontsource/tinos/latin-400-italic.css";
+@import "@fontsource/tinos/latin-700.css";
+
+.scv-root {
+  --scv-primary: #3c52a3;
+  --scv-primary-dark: #293b82;
+  --scv-primary-soft: #e8ecfb;
+  --scv-ink: #20242c;
+  --scv-ink-soft: #69717e;
+  --scv-paper: #f6f7fb;
+  --scv-panel: #ffffff;
+  --scv-line: #d9deea;
+  --scv-circular: #f0f3fb;
+  --scv-amber: #9a671e;
+  --scv-amber-soft: #fff3d8;
+  display: grid;
+  grid-template-columns: minmax(330px, 37fr) minmax(460px, 63fr);
+  min-width: 0;
+  height: 100vh;
+  overflow: hidden;
+  color: var(--scv-ink);
+  background: var(--scv-paper);
+  font-family: ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+.scv-root.scv-has-auxiliary {
+  grid-template-columns: minmax(320px, 27fr) minmax(430px, 35fr) minmax(380px, 38fr);
+}
+
+.scv-root *,
+.scv-root *::before,
+.scv-root *::after { box-sizing: border-box; }
+
+.scv-root button,
+.scv-root input { font: inherit; }
+
+.scv-root button,
+.scv-root a { -webkit-tap-highlight-color: transparent; }
+
+.scv-root button:focus-visible,
+.scv-root a:focus-visible,
+.scv-root input:focus-visible,
+.scv-root summary:focus-visible { outline: 2px solid var(--scv-primary); outline-offset: 2px; }
+
+.scv-index-pane,
+.scv-text-pane,
+.scv-auxiliary-pane { min-width: 0; height: 100vh; border-right: 1px solid var(--scv-line); }
+
+.scv-index-pane { position: relative; display: grid; grid-template-rows: 54px minmax(0, 1fr); overflow: hidden; background: #eef0f6; }
+
+.scv-search-toolbar { position: relative; z-index: 5; display: grid; grid-template-columns: minmax(0, 1fr) 48px; gap: 6px; padding: 7px; background: var(--scv-panel); border-bottom: 1px solid var(--scv-line); }
+
+.scv-search-form { display: grid; grid-template-columns: auto minmax(0, 1fr) auto auto; align-items: center; gap: 7px; min-width: 0; padding: 0 9px; color: var(--scv-ink-soft); background: #fafbfe; border: 1px solid var(--scv-line); border-radius: 6px; }
+
+.scv-search-form input { min-width: 0; padding: 8px 0; color: var(--scv-ink); font-size: 12px; background: transparent; border: 0; outline: 0; }
+.scv-search-form input::placeholder { color: #8a92a1; }
+.scv-search-form kbd { padding: 2px 5px; color: #8991a0; font-size: 9px; border: 1px solid var(--scv-line); border-radius: 3px; }
+.scv-clear-search { padding: 0 3px; color: var(--scv-ink-soft); background: transparent; border: 0; cursor: pointer; }
+.scv-settings-button { display: grid; place-items: center; color: var(--scv-primary-dark); background: var(--scv-primary-soft); border: 1px solid #c8d0ee; border-radius: 6px; cursor: pointer; }
+.scv-settings-button:hover { color: #fff; background: var(--scv-primary); }
+
+.scv-search-results { position: absolute; z-index: 10; top: 53px; left: 7px; right: 61px; display: grid; max-height: min(60vh, 510px); overflow: auto; padding: 5px; background: #fff; border: 1px solid var(--scv-line); border-radius: 0 0 7px 7px; box-shadow: 0 12px 28px rgb(34 45 75 / 16%); }
+.scv-search-result { display: grid; gap: 3px; padding: 9px 10px; color: var(--scv-ink); text-align: left; background: transparent; border: 0; border-radius: 5px; cursor: pointer; }
+.scv-search-result:hover, .scv-search-result:focus-visible { background: var(--scv-primary-soft); }
+.scv-search-result span { color: var(--scv-primary); font-size: 9px; font-weight: 800; letter-spacing: .04em; text-transform: uppercase; }
+.scv-search-result strong { font-family: "Tinos", serif; font-size: 16px; font-weight: 700; }
+.scv-search-result small { overflow: hidden; color: var(--scv-ink-soft); font-family: "Tinos", serif; font-size: 12px; line-height: 1.3; text-overflow: ellipsis; white-space: nowrap; }
+.scv-search-status { margin: 5px; padding: 11px; color: var(--scv-ink-soft); font-size: 11px; }
+
+.scv-index-grid { display: grid; min-height: 0; grid-template-columns: 1fr 1fr; grid-template-rows: 1fr 1fr; }
+.scv-index-cell { display: grid; min-width: 0; min-height: 0; grid-template-rows: 29px minmax(0, 1fr); border-right: 1px solid var(--scv-line); border-bottom: 1px solid var(--scv-line); }
+.scv-index-cell:nth-child(2) { grid-row: 2; grid-column: 1; }
+.scv-index-cell:nth-child(3) { grid-row: 1; grid-column: 2; }
+.scv-index-cell:nth-child(4) { grid-row: 2; grid-column: 2; }
+.scv-index-cell > header { display: flex; align-items: center; justify-content: space-between; padding: 0 9px; color: #737b8a; font-size: 8px; font-weight: 800; letter-spacing: .1em; text-transform: uppercase; background: #e4e7f0; border-bottom: 1px solid var(--scv-line); }
+.scv-index-cell > header b { color: #9aa2b1; font-size: 9px; font-variant-numeric: lining-nums; }
+.scv-index-list { min-height: 0; padding: 3px; overflow: auto; scrollbar-color: #b8c0d2 transparent; scrollbar-width: thin; }
+.scv-index-list button { display: grid; width: 100%; grid-template-columns: max-content minmax(0, 1fr); gap: 6px; padding: 5px 6px; color: #4f5867; text-align: left; background: transparent; border: 0; border-radius: 3px; cursor: pointer; }
+.scv-index-list button:hover { background: rgb(255 255 255 / 70%); }
+.scv-index-list button.active { color: #fff; background: var(--scv-primary); box-shadow: 0 2px 7px rgb(60 82 163 / 24%); }
+.scv-index-list strong { overflow: hidden; max-width: 62px; color: var(--scv-primary-dark); font-family: "Tinos", serif; font-size: 10px; font-variant-numeric: lining-nums; font-weight: 700; line-height: 1.35; text-overflow: ellipsis; white-space: nowrap; }
+.scv-index-list button.active strong { color: #fff; }
+.scv-index-list span { display: -webkit-box; overflow: hidden; font-family: "Tinos", serif; font-size: 11px; line-height: 1.2; -webkit-box-orient: vertical; -webkit-line-clamp: 2; }
+
+.scv-text-pane { position: relative; overflow: auto; background: #fff; scrollbar-color: #b1b8c7 transparent; scrollbar-width: thin; scroll-behavior: auto; }
+.scv-text-flow { width: min(100%, 790px); min-height: 100%; margin: 0 auto; padding: 23px 26px 55vh; }
+.scv-chunk-note { margin: 0 0 14px; padding-bottom: 9px; color: #8991a0; font-size: 8px; border-bottom: 1px solid #e2e5ed; }
+.scv-unit { scroll-margin-top: 14px; }
+.scv-unit h2 { display: block; margin: 5px 0 4px; color: var(--scv-ink); font-family: "Tinos", serif; font-size: 16px; font-weight: 700; line-height: 1.2; font-variant-numeric: lining-nums; }
+.scv-unit h2 span { margin-right: 7px; color: var(--scv-primary); font-family: "Tinos", serif; font-size: inherit; font-variant-numeric: lining-nums; font-weight: 700; white-space: nowrap; }
+.scv-unit-depth-0 h2 { margin-top: 18px; color: var(--scv-primary-dark); font-size: 19px; }
+.scv-unit:first-child h2 { margin-top: 0; }
+.scv-unit-blocks { display: block; }
+.scv-block { display: contents; }
+.scv-block p { display: inline; margin: 0; color: #272c35; font-family: "Tinos", serif; font-size: 13px; line-height: 1.48; }
+.scv-block p::after { content: " "; }
+.scv-block-heading, .scv-block-list-item, .scv-block-formula-ref, .scv-block-table-ref, .scv-block-figure-ref { display: block; }
+.scv-block-heading p { display: block; margin: 6px 0 2px; font-weight: 700; }
+.scv-block-list-item { padding-left: 11px; }
+.scv-block-list-item p::before { margin-right: 5px; color: var(--scv-primary); content: "–"; font-weight: 700; }
+.scv-related-unit { margin: 14px 0 18px; padding: 13px 15px; background: var(--scv-circular); border: 1px solid #cfd7ee; border-left: 3px solid var(--scv-primary); border-radius: 4px; }
+.scv-related-unit > header h3 { display: block; margin: 6px 0; color: var(--scv-primary); font-family: "Tinos", serif; font-size: 16px; font-variant-numeric: lining-nums; font-weight: 700; line-height: 1.2; }
+.scv-related-unit > header h3 span { margin-right: 7px; color: var(--scv-primary); font-family: "Tinos", serif; font-size: inherit; font-variant-numeric: lining-nums; font-weight: 700; white-space: nowrap; }
+.scv-end-note { margin-top: 34px; padding-top: 12px; color: #8991a0; font-family: "Tinos", serif; font-size: 11px; font-style: italic; border-top: 1px solid #e2e5ed; }
+
+.scv-root .inline-math { display: inline-block; margin-inline: .035em; color: #202733; font-size: .96em; white-space: nowrap; }
+.scv-root .formula-asset, .scv-root .table-asset, .scv-root .figure-asset { margin: 7px 0 9px; padding: 8px; overflow: hidden; background: #fff; border: 1px solid #dfe3ec; border-radius: 3px; box-shadow: none; }
+.scv-root .formula-row { display: flex; align-items: center; gap: 14px; }
+.scv-root .formula-scroll, .scv-root .table-scroll { max-width: 100%; overflow-x: auto; }
+.scv-root .formula-scroll { flex: 1 1 auto; min-width: 0; padding: 3px; font-size: .8rem; }
+.scv-root .formula-number { flex: 0 0 auto; margin-left: auto; color: var(--scv-primary-dark); font-family: "Tinos", serif; font-size: 12px; font-variant-numeric: lining-nums; white-space: nowrap; }
+.scv-root .formula-asset figcaption, .scv-root .table-asset figcaption, .scv-root .figure-asset figcaption { display: flex; align-items: baseline; justify-content: space-between; gap: 16px; margin-top: 5px; color: #687284; font-size: 8px; }
+.scv-root .table-asset figcaption { display: block; margin-bottom: 7px; }
+.scv-root .table-asset table { width: 100%; min-width: 520px; border-collapse: collapse; color: #2a3039; font-size: 8px; line-height: 1.42; }
+.scv-root .table-asset th, .scv-root .table-asset td { padding: 4px 5px; vertical-align: middle; border: 1px solid #c7ccda; }
+.scv-root .table-asset th { color: #fff; font-weight: 700; text-align: center; background: var(--scv-primary-dark); }
+.scv-root .table-asset td { background: #fbfcff; }
+.scv-root .table-asset tbody tr:nth-child(even) td { background: #f1f3f9; }
+.scv-root .table-notes { margin: 8px 0 0; padding-left: 17px; color: #6d7583; font-size: 9px; line-height: 1.4; }
+.scv-root .figure-asset img { display: block; width: auto; max-width: 100%; max-height: 430px; margin-inline: auto; object-fit: contain; }
+.scv-root .figure-asset figcaption { padding-top: 7px; border-top: 1px solid #dfe3ec; }
+.scv-root .asset-missing { padding: 12px; color: #8b342a !important; font-family: ui-sans-serif, sans-serif !important; font-size: 11px !important; background: #fff2ef; }
+
+.scv-loading, .scv-fatal { display: grid; min-height: 100%; place-content: center; gap: 10px; padding: 28px; color: var(--scv-ink-soft); text-align: center; }
+.scv-loading > span { width: 24px; height: 24px; justify-self: center; border: 2px solid #c6ccda; border-top-color: var(--scv-primary); border-radius: 50%; animation: scv-spin .8s linear infinite; }
+.scv-loading strong, .scv-fatal strong { font-family: "Tinos", serif; font-size: 14px; font-weight: 700; }
+.scv-fatal span { max-width: 300px; font-size: 10px; line-height: 1.5; }
+.scv-loading-rows { display: grid; gap: 9px; padding: 12px; }
+.scv-loading-rows span { height: 28px; background: linear-gradient(90deg, #e3e6ee, #f8f9fc, #e3e6ee); background-size: 200% 100%; border-radius: 4px; animation: scv-shimmer 1.8s infinite linear; }
+
+.scv-dialog-backdrop { position: fixed; z-index: 50; inset: 0; display: grid; place-items: center; padding: 20px; background: rgb(26 34 61 / 38%); }
+.scv-dialog { width: min(420px, 100%); padding: 20px; color: var(--scv-ink); background: #fff; border: 1px solid var(--scv-line); border-radius: 10px; box-shadow: 0 24px 70px rgb(22 31 65 / 25%); }
+.scv-dialog header { display: flex; align-items: center; justify-content: space-between; gap: 14px; margin-bottom: 18px; }
+.scv-dialog h2 { margin: 0; color: var(--scv-primary-dark); font-family: "Tinos", serif; font-size: 24px; }
+.scv-dialog header button { padding: 0 4px; color: var(--scv-ink-soft); font-size: 24px; line-height: 1; background: transparent; border: 0; cursor: pointer; }
+.scv-dialog fieldset { display: grid; gap: 10px; margin: 0; padding: 0; border: 0; }
+.scv-dialog legend { margin-bottom: 8px; color: var(--scv-ink-soft); font-size: 10px; font-weight: 800; letter-spacing: .1em; text-transform: uppercase; }
+.scv-dialog label { display: flex; align-items: center; gap: 9px; padding: 9px; font-size: 13px; border-radius: 5px; cursor: pointer; }
+.scv-dialog label:has(input:checked) { color: var(--scv-primary-dark); background: var(--scv-primary-soft); }
+.scv-dialog input { accent-color: var(--scv-primary); }
+.scv-auxiliary-toggle { margin-top: 17px; border-top: 1px solid var(--scv-line); }
+.scv-analytical-link { display: inline-block; margin-top: 17px; color: var(--scv-primary); font-size: 11px; font-weight: 700; }
+
+.scv-pdf-panel { height: 100%; overflow: auto; color: #edf0f7; background: #30343f; scrollbar-color: #777f91 #282c35; scrollbar-width: thin; }
+.scv-pdf-status { position: sticky; z-index: 4; top: 8px; display: flex; width: max-content; max-width: calc(100% - 28px); align-items: center; gap: 9px; margin: 8px auto -33px; padding: 6px 8px; color: #eef0f7; font-size: 8px; background: rgb(22 26 35 / 90%); border: 1px solid rgb(255 255 255 / 18%); border-radius: 4px; box-shadow: 0 2px 10px rgb(0 0 0 / 28%); backdrop-filter: blur(8px); }
+.scv-pdf-status strong { font-family: "Tinos", serif; font-size: 11px; }
+.scv-pdf-status span { color: #c4cad8; font-variant-numeric: lining-nums; }
+.scv-pdf-status a { color: #b9c5fb; text-decoration: none; }
+.scv-pdf-pages { display: grid; gap: 12px; padding: 46px 14px 55vh; }
+.scv-pdf-page { position: relative; width: 100%; min-height: 240px; aspect-ratio: .707 / 1; overflow: hidden; background: #fff; box-shadow: 0 2px 9px rgb(0 0 0 / 38%); }
+.scv-pdf-page > span { position: absolute; z-index: 2; top: 5px; right: 6px; padding: 2px 4px; color: #727772; font-size: 7px; background: rgb(255 255 255 / 78%); border-radius: 2px; }
+.scv-pdf-page canvas { display: block; width: 100% !important; height: auto !important; background: #fff; }
+.scv-pdf-consent { display: grid; min-height: 100%; place-content: center; gap: 10px; padding: 34px; text-align: center; }
+.scv-pdf-consent strong { font-family: "Tinos", serif; font-size: 19px; }
+.scv-pdf-consent p { max-width: 310px; margin: 0; color: #c6cbd7; font-size: 10px; line-height: 1.55; }
+.scv-pdf-consent button { justify-self: center; padding: 9px 13px; color: #fff; font-size: 10px; font-weight: 800; background: var(--scv-primary); border: 0; border-radius: 4px; cursor: pointer; }
+.scv-pdf-error { display: grid; min-height: 100%; place-content: center; gap: 8px; padding: 34px; text-align: center; }
+.scv-pdf-error strong { font-family: "Tinos", serif; font-size: 15px; }
+.scv-pdf-error span { color: #c6cbd7; font-size: 10px; }
+
+@keyframes scv-spin { to { transform: rotate(360deg); } }
+@keyframes scv-shimmer { to { background-position: -200% 0; } }
+
+@media (max-width: 1120px) {
+  .scv-root, .scv-root.scv-has-auxiliary { position: relative; display: grid; height: auto; min-height: 100vh; grid-template-columns: minmax(260px, 36fr) minmax(0, 64fr); overflow: visible; }
+  .scv-index-pane, .scv-text-pane { height: 76vh; }
+  .scv-auxiliary-pane { height: 70vh; grid-column: 1 / -1; border-right: 0; }
+}
+
+@media (max-width: 700px) {
+  .scv-root, .scv-root.scv-has-auxiliary { display: block; }
+  .scv-index-pane { height: 48vh; }
+  .scv-text-pane { height: auto; min-height: 58vh; }
+  .scv-text-flow { padding: 18px 16px 60px; }
+  .scv-auxiliary-pane { height: 72vh; }
+  .scv-search-form kbd { display: none; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .scv-root *, .scv-root *::before, .scv-root *::after { scroll-behavior: auto !important; animation-duration: .01ms !important; animation-iteration-count: 1 !important; }
+}