@world-engines/authoring-ui 0.1.0-alpha.0

package/dist/score/ScoreRadar.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useId } from "react";
+import "./score-radar.css";
+import { PRESENTATION_SCORE_AXES, STORY_SCORE_AXES, finiteScore, formatCompactScore, formatFullScore, scoreScaleValue, } from "./score-presentation.js";
+const SERIES = [
+    { key: "self", label: "本作品" },
+    { key: "mean", label: "标签均值" },
+    { key: "median", label: "标签中位数" },
+];
+function point(index, value, count) {
+    const angle = -Math.PI / 2 + (index * Math.PI * 2) / count;
+    const radius = 104 * (value / 100);
+    return [160 + Math.cos(angle) * radius, 160 + Math.sin(angle) * radius];
+}
+function pointText(position) {
+    return `${position[0].toFixed(2)} ${position[1].toFixed(2)}`;
+}
+function seriesPath(values) {
+    if (values.every((value) => value !== null)) {
+        return `${values.map((value, index) => `${index === 0 ? "M" : "L"} ${pointText(point(index, value, values.length))}`).join(" ")} Z`;
+    }
+    let connected = false;
+    return values.flatMap((value, index) => {
+        if (value === null) {
+            connected = false;
+            return [];
+        }
+        const command = connected ? "L" : "M";
+        connected = true;
+        return [`${command} ${pointText(point(index, value, values.length))}`];
+    }).join(" ");
+}
+function RadarCard({ title, axes, values, comparisonSelected, source, }) {
+    const titleId = useId();
+    const visibleSeries = SERIES.filter(({ key }) => key === "self" || (comparisonSelected && axes.some((axis) => finiteScore(values[axis.key]?.[key]) !== null)));
+    const outerPoints = axes.map((_, index) => point(index, 100, axes.length).join(",")).join(" ");
+    const hasSelfProfile = axes.some((axis) => finiteScore(values[axis.key]?.self) !== null);
+    return (_jsxs("article", { className: "score-radar__card", children: [_jsx("h3", { id: titleId, children: title }), _jsxs("svg", { className: "score-radar__plot", viewBox: "0 0 320 320", role: "img", "aria-labelledby": titleId, children: [[20, 40, 60, 80, 100].map((level) => (_jsx("polygon", { className: "score-radar__grid", points: axes.map((_, index) => point(index, level, axes.length).join(",")).join(" ") }, level))), axes.map((axis, index) => {
+                        const end = point(index, 100, axes.length);
+                        return _jsx("line", { className: "score-radar__spoke", x1: "160", y1: "160", x2: end[0], y2: end[1] }, axis.key);
+                    }), _jsx("polygon", { className: "score-radar__boundary", points: outerPoints }), axes.map((axis, index) => {
+                        const position = point(index, 127, axes.length);
+                        const x = position[0];
+                        const y = Math.min(305, Math.max(15, position[1]));
+                        return (_jsx("text", { className: "score-radar__axis-label", "data-axis-label": axis.key, x: x, y: y, textAnchor: x < 145 ? "end" : x > 175 ? "start" : "middle", dominantBaseline: "middle", children: axis.label }, `label-${axis.key}`));
+                    }), !hasSelfProfile && source === "reviewed" ? _jsx("text", { className: "score-radar__empty", x: "160", y: "160", textAnchor: "middle", children: "\u6682\u65E0\u5DF2\u5BA1\u6838\u753B\u50CF" }) : null, visibleSeries.map(({ key }) => {
+                        const scaled = axes.map((axis) => scoreScaleValue(values[axis.key]?.[key]));
+                        const path = seriesPath(scaled);
+                        return path ? _jsx("path", { className: `score-radar__series score-radar__series--${key}`, "data-series": key, d: path }, key) : null;
+                    }), visibleSeries.flatMap(({ key }) => axes.flatMap((axis, index) => {
+                        const scaled = scoreScaleValue(values[axis.key]?.[key]);
+                        if (scaled === null)
+                            return [];
+                        const position = point(index, scaled, axes.length);
+                        return [_jsx("circle", { className: `score-radar__point score-radar__point--${key}`, cx: position[0], cy: position[1], r: "3" }, `${key}-${axis.key}`)];
+                    }))] }), _jsx("ul", { className: "score-radar__values", "aria-label": `${title}各维度分数`, children: axes.map((axis) => (_jsxs("li", { children: [_jsx("span", { children: axis.label }), visibleSeries.map(({ key, label }) => {
+                            const value = finiteScore(values[axis.key]?.[key]);
+                            return _jsxs("span", { children: [_jsx("small", { children: label }), _jsx("strong", { title: formatFullScore(value), children: formatCompactScore(value) })] }, key);
+                        })] }, axis.key))) })] }));
+}
+export function ScoreRadar({ story, presentation, comparisonSelected, source, className = "" }) {
+    const sourceLabel = source === "draft" ? "本作品数据来源：草稿预估" : "本作品数据来源：已审核结果";
+    const hasMean = comparisonSelected && [...STORY_SCORE_AXES, ...PRESENTATION_SCORE_AXES].some((axis) => finiteScore((axis.key in story ? story[axis.key] : presentation[axis.key])?.mean) !== null);
+    const hasMedian = comparisonSelected && [...STORY_SCORE_AXES, ...PRESENTATION_SCORE_AXES].some((axis) => finiteScore((axis.key in story ? story[axis.key] : presentation[axis.key])?.median) !== null);
+    return (_jsxs("section", { className: `score-radar ${className}`.trim(), "aria-label": "\u4F5C\u54C1\u8BC4\u5206\u96F7\u8FBE\u56FE", children: [_jsxs("header", { className: "score-radar__header", children: [_jsxs("div", { children: [_jsx("h2", { children: "\u4F5C\u54C1\u8868\u73B0" }), _jsxs("p", { children: [sourceLabel, "\uFF1B\u5BF9\u6BD4\u7EBF\u4EC5\u5C55\u793A\u6807\u7B7E\u771F\u5B9E\u7EDF\u8BA1\u6570\u636E\u3002"] })] }), _jsxs("ul", { className: "score-radar__legend", "aria-label": "\u56FE\u4F8B", children: [_jsx("li", { "data-series": "self", children: "\u672C\u4F5C\u54C1" }), hasMean ? _jsx("li", { "data-series": "mean", children: "\u6807\u7B7E\u5747\u503C" }) : null, hasMedian ? _jsx("li", { "data-series": "median", children: "\u6807\u7B7E\u4E2D\u4F4D\u6570" }) : null] })] }), _jsxs("div", { className: "score-radar__cards", children: [_jsx(RadarCard, { title: "\u6545\u4E8B\u7ED3\u6784", axes: STORY_SCORE_AXES, values: story, comparisonSelected: comparisonSelected, source: source }), _jsx(RadarCard, { title: "\u5448\u73B0\u8D28\u91CF", axes: PRESENTATION_SCORE_AXES, values: presentation, comparisonSelected: comparisonSelected, source: source })] })] }));
+}

package/dist/score/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./scenario-scoring-features.js";
+export * from "./scenario-structural-score.js";
+export * from "./score-presentation.js";

package/dist/score/index.js

@@ -0,0 +1,3 @@
+export * from "./scenario-scoring-features.js";
+export * from "./scenario-structural-score.js";
+export * from "./score-presentation.js";

package/dist/score/radar-index.d.ts

@@ -0,0 +1,3 @@
+export { ScoreRadar } from "./ScoreRadar.js";
+export type { ScoreRadarProps } from "./ScoreRadar.js";
+export * from "./score-presentation.js";

package/dist/score/radar-index.js

@@ -0,0 +1,2 @@
+export { ScoreRadar } from "./ScoreRadar.js";
+export * from "./score-presentation.js";

package/dist/score/scenario-scoring-features.d.ts

@@ -0,0 +1,90 @@
+import type { StructuralInput } from "./scenario-structural-score.js";
+export type ArchetypeId = "solo_protagonist" | "world_codex" | "sparse_prototype" | "attribute_farm" | "ensemble_cast" | "relation_web" | "flat_graph" | "faction_conflict" | "location_atlas" | "item_catalog" | "event_driven" | "cg_gallery" | "voice_theater" | "puppet_show" | "text_heavyweight" | "ui_showcase" | "compact_tight" | "replay_hotspot" | "other";
+export interface PerTypeCounts {
+    readonly character: number;
+    readonly setting: number;
+    readonly lore: number;
+    readonly faction: number;
+    readonly location: number;
+    readonly event: number;
+    readonly item: number;
+    readonly other: number;
+}
+export interface MediaBreakdown {
+    readonly cg_image: number;
+    readonly cg_video: number;
+    readonly audio: number;
+    readonly puppet: number;
+    readonly other: number;
+}
+export interface CharacterGraphStats {
+    readonly relation_count: number;
+    readonly max_degree: number;
+    readonly min_degree: number;
+    readonly median_degree: number;
+    readonly p90_degree: number;
+    readonly leaf_count: number;
+    readonly max_child_node_count: number;
+    readonly median_child_node_count: number;
+    readonly max_effective_attr: number;
+    readonly min_effective_attr: number;
+    readonly median_effective_attr: number;
+    readonly p90_effective_attr: number;
+}
+export interface ScoringFeatureAssets {
+    readonly description_chars?: number;
+    readonly cover_variant_count?: number;
+    readonly has_view_ref?: boolean;
+    readonly ui_html_variant_count?: number;
+    readonly media_binding_count?: number;
+    readonly media_breakdown?: Partial<MediaBreakdown>;
+}
+export interface ScoringFeatureDiagnostics {
+    readonly excluded_entity_count: number;
+    readonly invalid_entity_count: number;
+    readonly excluded_relation_count: number;
+    readonly dangling_relation_count: number;
+    readonly self_loop_relation_count: number;
+    readonly duplicate_relation_count: number;
+    readonly duplicate_media_binding_count: number;
+}
+export interface ScenarioScoringFeatures {
+    readonly entity_count: number;
+    readonly relation_count: number;
+    readonly total_prop_keys: number;
+    readonly lore_entity_count: number;
+    readonly description_chars: number;
+    readonly entity_props_text_chars: number;
+    readonly cover_variant_count: number;
+    readonly has_view_ref: boolean;
+    readonly ui_html_variant_count: number;
+    readonly media_binding_count: number;
+    readonly max_edge: number;
+    readonly min_edge: number;
+    readonly median_edge: number;
+    readonly p90_edge: number;
+    readonly max_attr: number;
+    readonly min_attr: number;
+    readonly median_attr: number;
+    readonly per_type_counts: PerTypeCounts;
+    readonly character_graph: CharacterGraphStats;
+    readonly media_breakdown: MediaBreakdown;
+    readonly diagnostics: ScoringFeatureDiagnostics;
+}
+export interface ArchetypeRuntimeSignals {
+    readonly avg_save?: number;
+    readonly max_round?: number;
+    readonly fav_count?: number;
+}
+/**
+ * 从实体/关系 wire 数据提取与 Rust 同口径的可信特征。
+ * duplicate entity id 会抛 `duplicate_entity_id:<id>`，调用方必须 fail closed。
+ */
+export declare function extractScenarioScoringFeatures(params: {
+    readonly entities: ReadonlyArray<unknown>;
+    readonly relations: ReadonlyArray<unknown>;
+    readonly assets?: ScoringFeatureAssets;
+}): ScenarioScoringFeatures;
+export declare const toStructuralInput: (features: ScenarioScoringFeatures) => StructuralInput;
+export declare function detectAllMatchedArchetypes(input: ScenarioScoringFeatures, runtime?: ArchetypeRuntimeSignals): ArchetypeId[];
+export declare function detectPrimaryArchetype(input: ScenarioScoringFeatures, runtime?: ArchetypeRuntimeSignals): ArchetypeId;

package/dist/score/scenario-scoring-features.js

@@ -0,0 +1,380 @@
+const asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    ? value
+    : undefined;
+const asString = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+const normalizeToken = (raw) => raw.trim().toLowerCase().replace(/[- /]/g, "_");
+const sourceOrControlKind = (kind) => new Set([
+    "source_document", "source_chunk", "source_control", "control", "control_node",
+    "graph_control", "scenario_control", "system_control"
+]).has(kind)
+    || kind.startsWith("world_source_")
+    || kind.startsWith("source_")
+    || kind.startsWith("control_")
+    || kind.endsWith("_control");
+const normalizedKind = (raw) => {
+    const kind = normalizeToken(raw);
+    if (sourceOrControlKind(kind))
+        return undefined;
+    if (["character", "npc", "person", "role", "actor", "world_document_person"].includes(kind)) {
+        return "character";
+    }
+    if (["setting", "world_setting", "worldview"].includes(kind))
+        return "setting";
+    if (["lore", "world_lore", "codex"].includes(kind))
+        return "lore";
+    if (["faction", "organization", "organisation", "group"].includes(kind))
+        return "faction";
+    if (["location", "place", "site", "scene", "world_document_place"].includes(kind)) {
+        return "location";
+    }
+    if (["item", "object", "artifact", "prop", "world_document_object"].includes(kind)) {
+        return "item";
+    }
+    if (["event", "incident", "world_document_event"].includes(kind))
+        return "event";
+    return "other";
+};
+const entityId = (entity) => asString(entity.entity_id) ?? asString(entity.id);
+const relationEndpoint = (relation, keys) => {
+    for (const key of keys) {
+        const id = asString(relation[key]);
+        if (id !== undefined)
+            return id;
+    }
+    return undefined;
+};
+const boolMarker = (record, key) => {
+    if (record[key] === true)
+        return true;
+    return asRecord(record.props)?.[key] === true;
+};
+const technicalKey = (raw) => {
+    const key = normalizeToken(raw);
+    return new Set([
+        "raw_base64", "base64", "blob", "data_uri", "provenance", "source_ref", "source_refs",
+        "hash", "sha", "sha256", "digest", "checksum", "vector", "embedding", "embedding_hash",
+        "position", "needs_review", "created_at", "updated_at"
+    ]).has(key)
+        || ["_base64", "_hash", "_sha", "_sha256", "_digest", "_vector", "_embedding"]
+            .some((suffix) => key.endsWith(suffix));
+};
+const collectEffectiveLeaves = (value, path, output) => {
+    if (value === null || value === undefined)
+        return;
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed.length > 0)
+            output.push([path, trimmed, Array.from(trimmed).length]);
+        return;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        output.push([path, String(value), 0]);
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((item, index) => collectEffectiveLeaves(item, `${path}[${index}]`, output));
+        return;
+    }
+    const record = asRecord(value);
+    if (record === undefined)
+        return;
+    if (Object.prototype.hasOwnProperty.call(record, "value")) {
+        collectEffectiveLeaves(record.value, path, output);
+        return;
+    }
+    for (const key of Object.keys(record).sort()) {
+        if (technicalKey(key) || key === "trigger" || key === "states")
+            continue;
+        collectEffectiveLeaves(record[key], path.length === 0 ? key : `${path}.${key}`, output);
+    }
+};
+const effectiveAttrs = (entity) => {
+    const output = [];
+    const props = asRecord(entity.props);
+    if (props === undefined)
+        return output;
+    for (const key of Object.keys(props).sort()) {
+        if (technicalKey(key))
+            continue;
+        collectEffectiveLeaves(props[key], key, output);
+    }
+    return output;
+};
+const entityExcluded = (entity) => boolMarker(entity, "disabled")
+    || boolMarker(entity, "control")
+    || boolMarker(entity, "is_control")
+    || boolMarker(entity, "scoring_excluded")
+    || normalizedKind(typeof entity.kind === "string" ? entity.kind : "") === undefined;
+const relationExcluded = (relation) => {
+    const kind = normalizeToken(typeof relation.kind === "string" ? relation.kind : "");
+    return sourceOrControlKind(kind)
+        || kind.includes("source_chunk")
+        || boolMarker(relation, "disabled")
+        || boolMarker(relation, "control")
+        || boolMarker(relation, "is_control")
+        || boolMarker(relation, "scoring_excluded")
+        || asRecord(relation.props)?.structural === false;
+};
+const relationSignature = (relation, from, to) => {
+    const kind = normalizeToken(typeof relation.kind === "string" ? relation.kind : "related_to");
+    const leaves = [];
+    for (const key of ["title", "content", "props", "fields"]) {
+        if (relation[key] !== undefined)
+            collectEffectiveLeaves(relation[key], key, leaves);
+    }
+    leaves.sort(([aPath, aValue], [bPath, bValue]) => aPath.localeCompare(bPath) || aValue.localeCompare(bValue));
+    return `${from}\u001f${to}\u001f${kind}\u001f${leaves.map(([p, v]) => `${p}=${v}`).join("\u001e")}`;
+};
+const distribution = (input) => {
+    if (input.length === 0)
+        return [0, 0, 0, 0];
+    const values = [...input].sort((a, b) => a - b);
+    const p90 = Math.min(values.length - 1, Math.max(0, Math.ceil(values.length * 0.9) - 1));
+    return [values[values.length - 1] ?? 0, values[0] ?? 0, values[Math.floor(values.length / 2)] ?? 0, values[p90] ?? 0];
+};
+const mediaBreakdown = (input) => ({
+    cg_image: input?.cg_image ?? 0,
+    cg_video: input?.cg_video ?? 0,
+    audio: input?.audio ?? 0,
+    puppet: input?.puppet ?? 0,
+    other: input?.other ?? 0
+});
+/**
+ * 从实体/关系 wire 数据提取与 Rust 同口径的可信特征。
+ * duplicate entity id 会抛 `duplicate_entity_id:<id>`，调用方必须 fail closed。
+ */
+export function extractScenarioScoringFeatures(params) {
+    const entities = params.entities.map(asRecord);
+    const relations = params.relations.map(asRecord);
+    const seenIds = new Set();
+    for (const entity of entities) {
+        if (entity === undefined)
+            continue;
+        const id = entityId(entity);
+        if (id === undefined)
+            continue;
+        if (seenIds.has(id))
+            throw new Error(`duplicate_entity_id:${id}`);
+        seenIds.add(id);
+    }
+    const diagnostics = {
+        excluded_entity_count: 0,
+        invalid_entity_count: 0,
+        excluded_relation_count: 0,
+        dangling_relation_count: 0,
+        self_loop_relation_count: 0,
+        duplicate_relation_count: 0,
+        duplicate_media_binding_count: 0
+    };
+    const kinds = new Map();
+    const attrs = new Map();
+    const counts = {
+        character: 0, setting: 0, lore: 0, faction: 0, location: 0, event: 0, item: 0, other: 0
+    };
+    let entityPropsTextChars = 0;
+    let loreEntityCount = 0;
+    for (const entity of entities) {
+        if (entity === undefined) {
+            diagnostics.invalid_entity_count += 1;
+            continue;
+        }
+        const id = entityId(entity);
+        if (id === undefined) {
+            diagnostics.invalid_entity_count += 1;
+            continue;
+        }
+        if (entityExcluded(entity)) {
+            diagnostics.excluded_entity_count += 1;
+            continue;
+        }
+        const kind = normalizedKind(typeof entity.kind === "string" ? entity.kind : "") ?? "other";
+        const leaves = effectiveAttrs(entity);
+        attrs.set(id, leaves.length);
+        entityPropsTextChars += leaves.reduce((sum, [, , textChars]) => sum + textChars, 0);
+        kinds.set(id, kind);
+        counts[kind] += 1;
+        if (["setting", "lore", "faction", "location"].includes(kind))
+            loreEntityCount += 1;
+    }
+    const degree = new Map([...kinds.keys()].map((id) => [id, 0]));
+    const characterIds = new Set([...kinds].filter(([, kind]) => kind === "character").map(([id]) => id));
+    const characterNeighbors = new Map([...characterIds].map((id) => [id, new Set()]));
+    const seenRelations = new Set();
+    let relationCount = 0;
+    let characterRelationCount = 0;
+    for (const relation of relations) {
+        if (relation === undefined || relationExcluded(relation)) {
+            diagnostics.excluded_relation_count += 1;
+            continue;
+        }
+        const from = relationEndpoint(relation, ["from_id", "source_id", "from", "source"]);
+        const to = relationEndpoint(relation, ["to_id", "target_id", "to", "target"]);
+        if (from === undefined || to === undefined || !kinds.has(from) || !kinds.has(to)) {
+            diagnostics.dangling_relation_count += 1;
+            continue;
+        }
+        if (from === to) {
+            diagnostics.self_loop_relation_count += 1;
+            continue;
+        }
+        const signature = relationSignature(relation, from, to);
+        if (seenRelations.has(signature)) {
+            diagnostics.duplicate_relation_count += 1;
+            continue;
+        }
+        seenRelations.add(signature);
+        relationCount += 1;
+        degree.set(from, (degree.get(from) ?? 0) + 1);
+        degree.set(to, (degree.get(to) ?? 0) + 1);
+        const fromCharacter = characterIds.has(from);
+        const toCharacter = characterIds.has(to);
+        if (fromCharacter || toCharacter)
+            characterRelationCount += 1;
+        if (fromCharacter && !toCharacter)
+            characterNeighbors.get(from)?.add(to);
+        if (toCharacter && !fromCharacter)
+            characterNeighbors.get(to)?.add(from);
+    }
+    const [maxEdge, minEdge, medianEdge, p90Edge] = distribution([...degree.values()]);
+    const [maxAttr, minAttr, medianAttr] = distribution([...attrs.values()]);
+    const characterDegrees = [...characterIds].map((id) => degree.get(id) ?? 0);
+    const [characterMaxEdge, characterMinEdge, characterMedianEdge, characterP90Edge] = distribution(characterDegrees);
+    const [characterMaxAdjacent, , characterMedianAdjacent] = distribution([...characterNeighbors.values()].map((neighbors) => neighbors.size));
+    const [characterMaxAttr, characterMinAttr, characterMedianAttr, characterP90Attr] = distribution([...characterIds].map((id) => attrs.get(id) ?? 0));
+    const characterGraph = {
+        relation_count: characterRelationCount,
+        max_degree: characterMaxEdge,
+        min_degree: characterMinEdge,
+        median_degree: characterMedianEdge,
+        p90_degree: characterP90Edge,
+        leaf_count: characterDegrees.filter((value) => value <= 1).length,
+        max_child_node_count: characterMaxAdjacent,
+        median_child_node_count: characterMedianAdjacent,
+        max_effective_attr: characterMaxAttr,
+        min_effective_attr: characterMinAttr,
+        median_effective_attr: characterMedianAttr,
+        p90_effective_attr: characterP90Attr
+    };
+    const assets = params.assets;
+    return {
+        entity_count: kinds.size,
+        relation_count: relationCount,
+        total_prop_keys: [...attrs.values()].reduce((sum, value) => sum + value, 0),
+        lore_entity_count: loreEntityCount,
+        description_chars: assets?.description_chars ?? 0,
+        entity_props_text_chars: entityPropsTextChars,
+        cover_variant_count: assets?.cover_variant_count ?? 0,
+        has_view_ref: assets?.has_view_ref ?? false,
+        ui_html_variant_count: assets?.ui_html_variant_count ?? 0,
+        media_binding_count: assets?.media_binding_count ?? 0,
+        max_edge: maxEdge,
+        min_edge: minEdge,
+        median_edge: medianEdge,
+        p90_edge: p90Edge,
+        max_attr: maxAttr,
+        min_attr: minAttr,
+        median_attr: medianAttr,
+        per_type_counts: counts,
+        character_graph: characterGraph,
+        media_breakdown: mediaBreakdown(assets?.media_breakdown),
+        diagnostics
+    };
+}
+export const toStructuralInput = (features) => ({
+    entityCount: features.entity_count,
+    relationCount: features.relation_count,
+    totalPropKeys: features.total_prop_keys,
+    loreEntityCount: features.lore_entity_count,
+    descriptionChars: features.description_chars,
+    entityPropsTextChars: features.entity_props_text_chars,
+    coverVariantCount: features.cover_variant_count,
+    hasViewRef: features.has_view_ref,
+    uiHtmlVariantCount: features.ui_html_variant_count,
+    mediaBindingCount: features.media_binding_count
+});
+const graphEmpty = (graph) => Object.values(graph).every((value) => value === 0);
+const matchesSoloProtagonist = (input) => {
+    const characters = input.per_type_counts.character;
+    const graph = input.character_graph;
+    const maxDegree = graph.max_degree > 0 ? graph.max_degree : input.max_edge;
+    const medianDegree = !graphEmpty(graph) ? graph.median_degree : input.median_edge;
+    const incidentRelations = graph.relation_count > 0 ? graph.relation_count : input.relation_count;
+    const supportingCastIsPeripheral = characters === 1
+        || graph.leaf_count * 2 >= Math.max(0, characters - 1)
+        || graph.max_child_node_count >= 2
+        || graph.max_effective_attr >= graph.median_effective_attr + 4;
+    return characters >= 1
+        && input.entity_count >= 3
+        && input.relation_count >= 2
+        && maxDegree >= 3
+        && maxDegree / Math.max(medianDegree, 1) >= 3
+        && maxDegree >= incidentRelations * 0.5
+        && supportingCastIsPeripheral;
+};
+const matchesEnsembleCast = (input) => {
+    const graph = input.character_graph;
+    const maxDegree = graphEmpty(graph) ? input.max_edge : graph.max_degree;
+    const minDegree = graphEmpty(graph) ? input.min_edge : graph.min_degree;
+    const medianDegree = graphEmpty(graph) ? input.median_edge : graph.median_degree;
+    return input.per_type_counts.character >= 8
+        && medianDegree >= 2
+        && minDegree >= 1
+        && maxDegree / Math.max(medianDegree, 1) < 2;
+};
+export function detectAllMatchedArchetypes(input, runtime = {}) {
+    const p = input.per_type_counts;
+    const media = input.media_breakdown;
+    const hits = [];
+    const add = (id, matched) => { if (matched)
+        hits.push(id); };
+    add("solo_protagonist", matchesSoloProtagonist(input));
+    add("world_codex", input.entity_count >= 10 && p.character <= 3
+        && input.lore_entity_count / Math.max(input.entity_count, 1) >= 0.7
+        && p.setting + p.lore >= 8);
+    add("sparse_prototype", input.entity_count < 8 && input.relation_count < 5
+        && input.total_prop_keys < 20
+        && input.description_chars + input.entity_props_text_chars < 500
+        && input.media_binding_count === 0);
+    add("attribute_farm", input.entity_count >= 5 && input.median_attr >= 12 && input.min_attr >= 6
+        && input.entity_props_text_chars / Math.max(input.total_prop_keys, 1) <= 8);
+    add("ensemble_cast", matchesEnsembleCast(input));
+    add("relation_web", input.entity_count >= 6
+        && input.relation_count / Math.max(input.entity_count, 1) >= 3
+        && input.median_edge >= 4 && input.min_edge >= 2);
+    add("flat_graph", input.entity_count >= 10
+        && input.relation_count / Math.max(input.entity_count, 1) < 0.4
+        && input.median_edge === 0 && input.max_edge <= 2);
+    add("faction_conflict", p.faction >= 3 && p.character >= p.faction
+        && input.relation_count >= p.faction * p.faction / 2);
+    add("location_atlas", p.location >= 8
+        && p.location / Math.max(input.entity_count, 1) >= 0.4 && input.median_edge >= 2);
+    add("item_catalog", p.item >= 10
+        && p.item / Math.max(input.entity_count, 1) >= 0.4 && input.median_attr >= 6);
+    add("event_driven", p.event >= 6
+        && p.event / Math.max(input.entity_count, 1) >= 0.3
+        && input.relation_count / Math.max(p.event, 1) >= 1.5);
+    const cg = media.cg_image + media.cg_video;
+    add("cg_gallery", cg >= 20 && cg / Math.max(input.media_binding_count, 1) >= 0.7);
+    add("voice_theater", media.audio >= 15
+        && media.audio / Math.max(input.media_binding_count, 1) >= 0.4 && p.character >= 2);
+    add("puppet_show", media.puppet >= 3
+        && media.puppet / Math.max(input.media_binding_count, 1) >= 0.25 && p.character >= media.puppet);
+    add("text_heavyweight", input.description_chars + input.entity_props_text_chars >= 30_000
+        && input.entity_props_text_chars / Math.max(input.total_prop_keys, 1) >= 60);
+    add("ui_showcase", input.has_view_ref && input.ui_html_variant_count >= 2
+        && input.cover_variant_count >= 3);
+    add("compact_tight", input.entity_count >= 8 && input.entity_count <= 30
+        && input.max_edge >= input.min_edge && input.max_edge - input.min_edge <= 3
+        && input.max_attr >= input.min_attr && input.max_attr - input.min_attr <= 5
+        && input.median_edge >= 1 && input.median_attr >= 3);
+    add("replay_hotspot", (runtime.avg_save ?? 0) >= 3
+        && (runtime.max_round ?? 0) >= 100 && (runtime.fav_count ?? 0) >= 20);
+    return hits;
+}
+const PLAYER_ONLY = new Set(["replay_hotspot"]);
+export function detectPrimaryArchetype(input, runtime = {}) {
+    const hits = detectAllMatchedArchetypes(input, runtime);
+    if (hits.includes("sparse_prototype"))
+        return "sparse_prototype";
+    return hits.find((id) => !PLAYER_ONLY.has(id)) ?? "other";
+}

package/dist/score/scenario-structural-score.d.ts

@@ -0,0 +1,76 @@
+import { type ArchetypeId, type ScenarioScoringFeatures } from "./scenario-scoring-features.js";
+export declare const STRUCTURAL_WEIGHT_ENTITY_COUNT = 22;
+export declare const STRUCTURAL_WEIGHT_RELATION_COUNT = 20;
+export declare const STRUCTURAL_WEIGHT_ATTR_RICHNESS = 16;
+export declare const STRUCTURAL_WEIGHT_LORE_COMPLETENESS = 16;
+export declare const STRUCTURAL_WEIGHT_TEXT_VOLUME = 14;
+export declare const STRUCTURAL_WEIGHT_ASSET_REFS = 12;
+export declare const STRUCTURAL_SAT_K_ENTITY_COUNT = 60;
+export declare const STRUCTURAL_SAT_K_RELATION_COUNT = 80;
+export declare const STRUCTURAL_SAT_K_ATTR_RICHNESS = 6;
+export declare const STRUCTURAL_SAT_K_LORE_COMPLETENESS = 8;
+export declare const STRUCTURAL_SAT_K_TEXT_VOLUME = 4000;
+export declare const STRUCTURAL_SAT_K_ASSET_REFS = 12;
+export interface StructuralInput {
+    readonly entityCount: number;
+    readonly relationCount: number;
+    readonly totalPropKeys: number;
+    readonly loreEntityCount: number;
+    readonly descriptionChars: number;
+    readonly entityPropsTextChars: number;
+    readonly coverVariantCount: number;
+    readonly hasViewRef: boolean;
+    readonly uiHtmlVariantCount: number;
+    readonly mediaBindingCount: number;
+}
+export interface StructuralSourceInput {
+    readonly entities: ReadonlyArray<unknown>;
+    readonly relations: ReadonlyArray<unknown>;
+    readonly description: string;
+    readonly coverVariantCount: number;
+    readonly hasViewRef: boolean;
+    readonly uiHtmlVariantCount: number;
+    readonly mediaBindingCount: number;
+}
+export interface LocalStructuralProjectionInput {
+    readonly entities: ReadonlyArray<unknown>;
+    readonly relations: ReadonlyArray<unknown>;
+    readonly description: string;
+    readonly source_revision: number;
+    readonly source_digest: string;
+}
+export interface LocalStructuralProjection {
+    readonly source_revision: number;
+    readonly source_digest: string;
+    readonly features: ScenarioScoringFeatures;
+    readonly archetype: {
+        readonly primary: ArchetypeId;
+        readonly all_matched: readonly ArchetypeId[];
+    };
+    readonly structural: {
+        readonly score: number;
+        readonly dimensions: StructuralDims;
+    };
+    readonly quality: null;
+    readonly base: null;
+}
+export interface StructuralDims {
+    readonly entity_count: number;
+    readonly relation_count: number;
+    readonly attr_richness: number;
+    readonly lore_completeness: number;
+    readonly text_volume: number;
+    readonly asset_refs: number;
+}
+export declare function sat(x: number, k: number): number;
+export declare function computeStructuralDims(input: StructuralInput): StructuralDims;
+/** 与 Rust `compute_structural_dims_with_archetype` 保持同口径。 */
+export declare function computeStructuralDimsWithArchetype(input: StructuralInput, features: ScenarioScoringFeatures, archetypeId: ArchetypeId): StructuralDims;
+export declare function computeStructuralScoreWithArchetype(input: StructuralInput, features: ScenarioScoringFeatures, archetypeId: ArchetypeId): number;
+export declare function sumStructuralDims(dims: StructuralDims): number;
+export declare function computeStructuralScore(input: StructuralInput): number;
+/** Host-facing descriptive alias；与历史 computeStructuralScore 使用同一公式实现。 */
+export declare const computeScenarioStructuralScore: typeof computeStructuralScore;
+export declare function buildStructuralInput(params: StructuralSourceInput): StructuralInput;
+/** 本地顶部预估只使用结构事实；不接受 media 自报值，也不伪造 quality/base 或 dual-radar 轴。 */
+export declare function computeLocalStructuralProjection(input: LocalStructuralProjectionInput): LocalStructuralProjection;