@tiangong-lca/cli 0.0.6 → 0.0.8

package/dist/src/lib/runtime-rulesets.js

@@ -0,0 +1,283 @@
+export const RUNTIME_RULESET_SOURCE_VERSION = '2026.05.23';
+export const RUNTIME_RULESET_VERSION = '1';
+const RUNTIME_RULES = [
+    {
+        id: 'tidas.process.name.base-name.align-reference-flow',
+        dataset_type: 'process',
+        severity: 'blocker',
+        default_blocker: true,
+        phases: ['build-plan', 'materialize', 'publish-build', 'save-draft', 'publish-run'],
+    },
+    {
+        id: 'tidas.process.name.qualifiers.structured',
+        dataset_type: 'process',
+        severity: 'warning',
+        default_blocker: false,
+        phases: ['build-plan', 'materialize', 'publish-build'],
+    },
+    {
+        id: 'tidas.process.quantitative-reference.required',
+        dataset_type: 'process',
+        severity: 'blocker',
+        default_blocker: true,
+        phases: ['build-plan', 'materialize', 'publish-build', 'save-draft', 'publish-run'],
+    },
+    {
+        id: 'tidas.process.exchange.amount.required',
+        dataset_type: 'process',
+        severity: 'blocker',
+        default_blocker: true,
+        phases: ['build-plan', 'materialize', 'publish-build', 'save-draft', 'publish-run'],
+    },
+    {
+        id: 'tidas.process.evidence.field-bindings.required',
+        dataset_type: 'process',
+        severity: 'blocker',
+        default_blocker: true,
+        phases: ['build-plan', 'materialize', 'publish-build', 'publish-run'],
+    },
+    {
+        id: 'tidas.process.version.format',
+        dataset_type: 'process',
+        severity: 'blocker',
+        default_blocker: true,
+        phases: ['save-draft', 'publish-build', 'publish-run'],
+    },
+    {
+        id: 'tidas.process.identity.duplicate-fingerprint.block',
+        dataset_type: 'process',
+        severity: 'blocker',
+        default_blocker: true,
+        phases: ['identity-preflight', 'dedup-review'],
+    },
+    {
+        id: 'tidas.flow.name.base-name.technical',
+        dataset_type: 'flow',
+        severity: 'blocker',
+        default_blocker: true,
+        phases: ['build-plan', 'materialize', 'publish-build', 'save-draft', 'publish-run'],
+    },
+    {
+        id: 'tidas.flow.type.required',
+        dataset_type: 'flow',
+        severity: 'blocker',
+        default_blocker: true,
+        phases: ['build-plan', 'materialize', 'publish-build', 'save-draft', 'publish-run'],
+    },
+    {
+        id: 'tidas.flow.reference-property-unit.required',
+        dataset_type: 'flow',
+        severity: 'blocker',
+        default_blocker: true,
+        phases: ['build-plan', 'materialize', 'publish-build', 'save-draft', 'publish-run'],
+    },
+    {
+        id: 'tidas.flow.flow-property.mean-value.positive',
+        dataset_type: 'flow',
+        severity: 'blocker',
+        default_blocker: true,
+        phases: ['materialize', 'publish-build', 'save-draft', 'publish-run'],
+    },
+    {
+        id: 'tidas.flow.classification.elementary.valid',
+        dataset_type: 'flow',
+        severity: 'blocker',
+        default_blocker: true,
+        phases: ['materialize', 'publish-build', 'save-draft', 'publish-run'],
+    },
+    {
+        id: 'tidas.flow.evidence.field-bindings.required',
+        dataset_type: 'flow',
+        severity: 'blocker',
+        default_blocker: true,
+        phases: ['build-plan', 'materialize', 'publish-build', 'publish-run'],
+    },
+    {
+        id: 'tidas.flow.identity.alias-equivalence.review',
+        dataset_type: 'flow',
+        severity: 'warning',
+        default_blocker: false,
+        phases: ['identity-preflight', 'dedup-review'],
+    },
+    {
+        id: 'tidas.publish.verification.required',
+        dataset_type: 'publish',
+        severity: 'blocker',
+        default_blocker: true,
+        phases: ['publish-run'],
+    },
+];
+const RULESETS = [
+    {
+        id: 'process-authoring/strict',
+        version: RUNTIME_RULESET_VERSION,
+        source_version: RUNTIME_RULESET_SOURCE_VERSION,
+        dataset_type: 'process',
+        phase: 'authoring',
+        rule_ids: [
+            'tidas.process.name.base-name.align-reference-flow',
+            'tidas.process.name.qualifiers.structured',
+            'tidas.process.quantitative-reference.required',
+            'tidas.process.exchange.amount.required',
+            'tidas.process.evidence.field-bindings.required',
+        ],
+    },
+    {
+        id: 'process-authoring/repair',
+        version: RUNTIME_RULESET_VERSION,
+        source_version: RUNTIME_RULESET_SOURCE_VERSION,
+        dataset_type: 'process',
+        phase: 'repair',
+        rule_ids: [
+            'tidas.process.quantitative-reference.required',
+            'tidas.process.exchange.amount.required',
+            'tidas.process.evidence.field-bindings.required',
+            'tidas.process.version.format',
+        ],
+    },
+    {
+        id: 'process-publish/default',
+        version: RUNTIME_RULESET_VERSION,
+        source_version: RUNTIME_RULESET_SOURCE_VERSION,
+        dataset_type: 'process',
+        phase: 'publish',
+        rule_ids: [
+            'tidas.process.name.base-name.align-reference-flow',
+            'tidas.process.quantitative-reference.required',
+            'tidas.process.exchange.amount.required',
+            'tidas.process.evidence.field-bindings.required',
+            'tidas.process.version.format',
+        ],
+    },
+    {
+        id: 'process-dedup/default',
+        version: RUNTIME_RULESET_VERSION,
+        source_version: RUNTIME_RULESET_SOURCE_VERSION,
+        dataset_type: 'process',
+        phase: 'identity',
+        rule_ids: ['tidas.process.identity.duplicate-fingerprint.block'],
+    },
+    {
+        id: 'flow-authoring/strict',
+        version: RUNTIME_RULESET_VERSION,
+        source_version: RUNTIME_RULESET_SOURCE_VERSION,
+        dataset_type: 'flow',
+        phase: 'authoring',
+        rule_ids: [
+            'tidas.flow.name.base-name.technical',
+            'tidas.flow.type.required',
+            'tidas.flow.reference-property-unit.required',
+            'tidas.flow.flow-property.mean-value.positive',
+            'tidas.flow.classification.elementary.valid',
+            'tidas.flow.evidence.field-bindings.required',
+            'tidas.flow.identity.alias-equivalence.review',
+        ],
+    },
+    {
+        id: 'flow-publish/default',
+        version: RUNTIME_RULESET_VERSION,
+        source_version: RUNTIME_RULESET_SOURCE_VERSION,
+        dataset_type: 'flow',
+        phase: 'publish',
+        rule_ids: [
+            'tidas.flow.name.base-name.technical',
+            'tidas.flow.type.required',
+            'tidas.flow.reference-property-unit.required',
+            'tidas.flow.classification.elementary.valid',
+            'tidas.flow.flow-property.mean-value.positive',
+            'tidas.flow.evidence.field-bindings.required',
+        ],
+    },
+    {
+        id: 'flow-dedup/default',
+        version: RUNTIME_RULESET_VERSION,
+        source_version: RUNTIME_RULESET_SOURCE_VERSION,
+        dataset_type: 'flow',
+        phase: 'identity',
+        rule_ids: ['tidas.flow.identity.alias-equivalence.review'],
+    },
+    {
+        id: 'publish-run/default',
+        version: RUNTIME_RULESET_VERSION,
+        source_version: RUNTIME_RULESET_SOURCE_VERSION,
+        dataset_type: 'publish',
+        phase: 'verification',
+        rule_ids: ['tidas.publish.verification.required'],
+    },
+];
+const RULESETS_BY_ID = Object.fromEntries(RULESETS.map((item) => [item.id, item]));
+const RULES_BY_ID = Object.fromEntries(RUNTIME_RULES.map((item) => [item.id, item]));
+const LOCAL_RULE_ID_MAP = {
+    'process-authoring/strict': {
+        process_missing_bilingual_base_name: 'tidas.process.name.base-name.align-reference-flow',
+        process_missing_functional_unit: 'tidas.process.quantitative-reference.required',
+        process_missing_quantitative_reference: 'tidas.process.quantitative-reference.required',
+        process_missing_exchange_amount: 'tidas.process.exchange.amount.required',
+        process_material_balance_deviation: 'tidas.process.exchange.amount.required',
+        process_missing_system_boundary: 'tidas.process.evidence.field-bindings.required',
+        process_missing_time: 'tidas.process.evidence.field-bindings.required',
+        process_missing_geography: 'tidas.process.evidence.field-bindings.required',
+        process_missing_technology: 'tidas.process.evidence.field-bindings.required',
+        process_missing_admin_metadata: 'tidas.process.evidence.field-bindings.required',
+        process_exchange_unit_semantic_mismatch: 'tidas.process.exchange.amount.required',
+    },
+    'process-dedup/default': {
+        process_exact_duplicate_fingerprint: 'tidas.process.identity.duplicate-fingerprint.block',
+    },
+    'process-publish/default': {
+        process_schema_failed: 'tidas.process.evidence.field-bindings.required',
+    },
+    'flow-authoring/strict': {
+        missing_type_of_dataset: 'tidas.flow.type.required',
+        elementary_flow_in_flow_review: 'tidas.flow.type.required',
+        methodology_invalid_type_of_dataset: 'tidas.flow.type.required',
+        missing_name_text: 'tidas.flow.name.base-name.technical',
+        name_contains_emergy: 'tidas.flow.name.base-name.technical',
+        methodology_missing_base_name_en: 'tidas.flow.name.base-name.technical',
+        methodology_basename_semicolon: 'tidas.flow.name.base-name.technical',
+        missing_classification_leaf: 'tidas.flow.classification.elementary.valid',
+        methodology_missing_class_id: 'tidas.flow.classification.elementary.valid',
+        methodology_missing_cat_id: 'tidas.flow.classification.elementary.valid',
+        methodology_product_classification_level_gap: 'tidas.flow.classification.elementary.valid',
+        methodology_elementary_classification_level_gap: 'tidas.flow.classification.elementary.valid',
+        missing_flow_property: 'tidas.flow.reference-property-unit.required',
+        invalid_flow_property_reference: 'tidas.flow.reference-property-unit.required',
+        missing_quantitative_reference: 'tidas.flow.reference-property-unit.required',
+        quantitative_reference_mismatch: 'tidas.flow.reference-property-unit.required',
+        methodology_quant_ref_missing_target: 'tidas.flow.reference-property-unit.required',
+        same_category_high_similarity: 'tidas.flow.identity.alias-equivalence.review',
+    },
+    'flow-publish/default': {
+        flow_schema_failed: 'tidas.flow.evidence.field-bindings.required',
+    },
+    'flow-dedup/default': {
+        same_property_semantic_review: 'tidas.flow.identity.alias-equivalence.review',
+    },
+};
+export function listRuntimeRulesets() {
+    return RULESETS.map((ruleset) => ({ ...ruleset, rule_ids: [...ruleset.rule_ids] }));
+}
+export function getRuntimeRuleset(id) {
+    const ruleset = RULESETS_BY_ID[id];
+    return { ...ruleset, rule_ids: [...ruleset.rule_ids] };
+}
+export function getRuntimeRule(id) {
+    const rule = RULES_BY_ID[id];
+    return rule ? { ...rule, phases: [...rule.phases] } : null;
+}
+export function runtimeRuleIds(id) {
+    return getRuntimeRuleset(id).rule_ids;
+}
+export function resolveRuntimeRuleId(rulesetId, localRuleId) {
+    if (!localRuleId) {
+        return null;
+    }
+    return LOCAL_RULE_ID_MAP[rulesetId]?.[localRuleId] ?? null;
+}
+export function isRuntimeRuleBlocker(ruleId) {
+    if (!ruleId) {
+        return false;
+    }
+    return RULES_BY_ID[ruleId]?.default_blocker ?? false;
+}
+//# sourceMappingURL=runtime-rulesets.js.map

package/dist/src/lib/runtime-rulesets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-rulesets.js","sourceRoot":"","sources":["../../../src/lib/runtime-rulesets.ts"],"names":[],"mappings":"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","sourcesContent":["export type RuntimeDatasetType = 'process' | 'flow' | 'publish';\nexport type RuntimeRuleSeverity = 'info' | 'warning' | 'blocker';\nexport type RuntimeRulesetPhase = 'authoring' | 'repair' | 'publish' | 'identity' | 'verification';\n\nexport type RuntimeRulesetId =\n  | 'process-authoring/strict'\n  | 'process-authoring/repair'\n  | 'process-publish/default'\n  | 'process-dedup/default'\n  | 'flow-authoring/strict'\n  | 'flow-publish/default'\n  | 'flow-dedup/default'\n  | 'publish-run/default';\n\nexport type RuntimeRule = {\n  id: string;\n  dataset_type: RuntimeDatasetType;\n  severity: RuntimeRuleSeverity;\n  default_blocker: boolean;\n  phases: string[];\n};\n\nexport type RuntimeRuleset = {\n  id: RuntimeRulesetId;\n  version: '1';\n  source_version: typeof RUNTIME_RULESET_SOURCE_VERSION;\n  dataset_type: RuntimeDatasetType;\n  phase: RuntimeRulesetPhase;\n  rule_ids: string[];\n};\n\nexport const RUNTIME_RULESET_SOURCE_VERSION = '2026.05.23';\nexport const RUNTIME_RULESET_VERSION = '1';\n\nconst RUNTIME_RULES = [\n  {\n    id: 'tidas.process.name.base-name.align-reference-flow',\n    dataset_type: 'process',\n    severity: 'blocker',\n    default_blocker: true,\n    phases: ['build-plan', 'materialize', 'publish-build', 'save-draft', 'publish-run'],\n  },\n  {\n    id: 'tidas.process.name.qualifiers.structured',\n    dataset_type: 'process',\n    severity: 'warning',\n    default_blocker: false,\n    phases: ['build-plan', 'materialize', 'publish-build'],\n  },\n  {\n    id: 'tidas.process.quantitative-reference.required',\n    dataset_type: 'process',\n    severity: 'blocker',\n    default_blocker: true,\n    phases: ['build-plan', 'materialize', 'publish-build', 'save-draft', 'publish-run'],\n  },\n  {\n    id: 'tidas.process.exchange.amount.required',\n    dataset_type: 'process',\n    severity: 'blocker',\n    default_blocker: true,\n    phases: ['build-plan', 'materialize', 'publish-build', 'save-draft', 'publish-run'],\n  },\n  {\n    id: 'tidas.process.evidence.field-bindings.required',\n    dataset_type: 'process',\n    severity: 'blocker',\n    default_blocker: true,\n    phases: ['build-plan', 'materialize', 'publish-build', 'publish-run'],\n  },\n  {\n    id: 'tidas.process.version.format',\n    dataset_type: 'process',\n    severity: 'blocker',\n    default_blocker: true,\n    phases: ['save-draft', 'publish-build', 'publish-run'],\n  },\n  {\n    id: 'tidas.process.identity.duplicate-fingerprint.block',\n    dataset_type: 'process',\n    severity: 'blocker',\n    default_blocker: true,\n    phases: ['identity-preflight', 'dedup-review'],\n  },\n  {\n    id: 'tidas.flow.name.base-name.technical',\n    dataset_type: 'flow',\n    severity: 'blocker',\n    default_blocker: true,\n    phases: ['build-plan', 'materialize', 'publish-build', 'save-draft', 'publish-run'],\n  },\n  {\n    id: 'tidas.flow.type.required',\n    dataset_type: 'flow',\n    severity: 'blocker',\n    default_blocker: true,\n    phases: ['build-plan', 'materialize', 'publish-build', 'save-draft', 'publish-run'],\n  },\n  {\n    id: 'tidas.flow.reference-property-unit.required',\n    dataset_type: 'flow',\n    severity: 'blocker',\n    default_blocker: true,\n    phases: ['build-plan', 'materialize', 'publish-build', 'save-draft', 'publish-run'],\n  },\n  {\n    id: 'tidas.flow.flow-property.mean-value.positive',\n    dataset_type: 'flow',\n    severity: 'blocker',\n    default_blocker: true,\n    phases: ['materialize', 'publish-build', 'save-draft', 'publish-run'],\n  },\n  {\n    id: 'tidas.flow.classification.elementary.valid',\n    dataset_type: 'flow',\n    severity: 'blocker',\n    default_blocker: true,\n    phases: ['materialize', 'publish-build', 'save-draft', 'publish-run'],\n  },\n  {\n    id: 'tidas.flow.evidence.field-bindings.required',\n    dataset_type: 'flow',\n    severity: 'blocker',\n    default_blocker: true,\n    phases: ['build-plan', 'materialize', 'publish-build', 'publish-run'],\n  },\n  {\n    id: 'tidas.flow.identity.alias-equivalence.review',\n    dataset_type: 'flow',\n    severity: 'warning',\n    default_blocker: false,\n    phases: ['identity-preflight', 'dedup-review'],\n  },\n  {\n    id: 'tidas.publish.verification.required',\n    dataset_type: 'publish',\n    severity: 'blocker',\n    default_blocker: true,\n    phases: ['publish-run'],\n  },\n] as const satisfies RuntimeRule[];\n\nconst RULESETS = [\n  {\n    id: 'process-authoring/strict',\n    version: RUNTIME_RULESET_VERSION,\n    source_version: RUNTIME_RULESET_SOURCE_VERSION,\n    dataset_type: 'process',\n    phase: 'authoring',\n    rule_ids: [\n      'tidas.process.name.base-name.align-reference-flow',\n      'tidas.process.name.qualifiers.structured',\n      'tidas.process.quantitative-reference.required',\n      'tidas.process.exchange.amount.required',\n      'tidas.process.evidence.field-bindings.required',\n    ],\n  },\n  {\n    id: 'process-authoring/repair',\n    version: RUNTIME_RULESET_VERSION,\n    source_version: RUNTIME_RULESET_SOURCE_VERSION,\n    dataset_type: 'process',\n    phase: 'repair',\n    rule_ids: [\n      'tidas.process.quantitative-reference.required',\n      'tidas.process.exchange.amount.required',\n      'tidas.process.evidence.field-bindings.required',\n      'tidas.process.version.format',\n    ],\n  },\n  {\n    id: 'process-publish/default',\n    version: RUNTIME_RULESET_VERSION,\n    source_version: RUNTIME_RULESET_SOURCE_VERSION,\n    dataset_type: 'process',\n    phase: 'publish',\n    rule_ids: [\n      'tidas.process.name.base-name.align-reference-flow',\n      'tidas.process.quantitative-reference.required',\n      'tidas.process.exchange.amount.required',\n      'tidas.process.evidence.field-bindings.required',\n      'tidas.process.version.format',\n    ],\n  },\n  {\n    id: 'process-dedup/default',\n    version: RUNTIME_RULESET_VERSION,\n    source_version: RUNTIME_RULESET_SOURCE_VERSION,\n    dataset_type: 'process',\n    phase: 'identity',\n    rule_ids: ['tidas.process.identity.duplicate-fingerprint.block'],\n  },\n  {\n    id: 'flow-authoring/strict',\n    version: RUNTIME_RULESET_VERSION,\n    source_version: RUNTIME_RULESET_SOURCE_VERSION,\n    dataset_type: 'flow',\n    phase: 'authoring',\n    rule_ids: [\n      'tidas.flow.name.base-name.technical',\n      'tidas.flow.type.required',\n      'tidas.flow.reference-property-unit.required',\n      'tidas.flow.flow-property.mean-value.positive',\n      'tidas.flow.classification.elementary.valid',\n      'tidas.flow.evidence.field-bindings.required',\n      'tidas.flow.identity.alias-equivalence.review',\n    ],\n  },\n  {\n    id: 'flow-publish/default',\n    version: RUNTIME_RULESET_VERSION,\n    source_version: RUNTIME_RULESET_SOURCE_VERSION,\n    dataset_type: 'flow',\n    phase: 'publish',\n    rule_ids: [\n      'tidas.flow.name.base-name.technical',\n      'tidas.flow.type.required',\n      'tidas.flow.reference-property-unit.required',\n      'tidas.flow.classification.elementary.valid',\n      'tidas.flow.flow-property.mean-value.positive',\n      'tidas.flow.evidence.field-bindings.required',\n    ],\n  },\n  {\n    id: 'flow-dedup/default',\n    version: RUNTIME_RULESET_VERSION,\n    source_version: RUNTIME_RULESET_SOURCE_VERSION,\n    dataset_type: 'flow',\n    phase: 'identity',\n    rule_ids: ['tidas.flow.identity.alias-equivalence.review'],\n  },\n  {\n    id: 'publish-run/default',\n    version: RUNTIME_RULESET_VERSION,\n    source_version: RUNTIME_RULESET_SOURCE_VERSION,\n    dataset_type: 'publish',\n    phase: 'verification',\n    rule_ids: ['tidas.publish.verification.required'],\n  },\n] as const satisfies RuntimeRuleset[];\n\nconst RULESETS_BY_ID = Object.fromEntries(RULESETS.map((item) => [item.id, item]));\nconst RULES_BY_ID = Object.fromEntries(RUNTIME_RULES.map((item) => [item.id, item]));\n\nconst LOCAL_RULE_ID_MAP: Partial<Record<RuntimeRulesetId, Record<string, string>>> = {\n  'process-authoring/strict': {\n    process_missing_bilingual_base_name: 'tidas.process.name.base-name.align-reference-flow',\n    process_missing_functional_unit: 'tidas.process.quantitative-reference.required',\n    process_missing_quantitative_reference: 'tidas.process.quantitative-reference.required',\n    process_missing_exchange_amount: 'tidas.process.exchange.amount.required',\n    process_material_balance_deviation: 'tidas.process.exchange.amount.required',\n    process_missing_system_boundary: 'tidas.process.evidence.field-bindings.required',\n    process_missing_time: 'tidas.process.evidence.field-bindings.required',\n    process_missing_geography: 'tidas.process.evidence.field-bindings.required',\n    process_missing_technology: 'tidas.process.evidence.field-bindings.required',\n    process_missing_admin_metadata: 'tidas.process.evidence.field-bindings.required',\n    process_exchange_unit_semantic_mismatch: 'tidas.process.exchange.amount.required',\n  },\n  'process-dedup/default': {\n    process_exact_duplicate_fingerprint: 'tidas.process.identity.duplicate-fingerprint.block',\n  },\n  'process-publish/default': {\n    process_schema_failed: 'tidas.process.evidence.field-bindings.required',\n  },\n  'flow-authoring/strict': {\n    missing_type_of_dataset: 'tidas.flow.type.required',\n    elementary_flow_in_flow_review: 'tidas.flow.type.required',\n    methodology_invalid_type_of_dataset: 'tidas.flow.type.required',\n    missing_name_text: 'tidas.flow.name.base-name.technical',\n    name_contains_emergy: 'tidas.flow.name.base-name.technical',\n    methodology_missing_base_name_en: 'tidas.flow.name.base-name.technical',\n    methodology_basename_semicolon: 'tidas.flow.name.base-name.technical',\n    missing_classification_leaf: 'tidas.flow.classification.elementary.valid',\n    methodology_missing_class_id: 'tidas.flow.classification.elementary.valid',\n    methodology_missing_cat_id: 'tidas.flow.classification.elementary.valid',\n    methodology_product_classification_level_gap: 'tidas.flow.classification.elementary.valid',\n    methodology_elementary_classification_level_gap: 'tidas.flow.classification.elementary.valid',\n    missing_flow_property: 'tidas.flow.reference-property-unit.required',\n    invalid_flow_property_reference: 'tidas.flow.reference-property-unit.required',\n    missing_quantitative_reference: 'tidas.flow.reference-property-unit.required',\n    quantitative_reference_mismatch: 'tidas.flow.reference-property-unit.required',\n    methodology_quant_ref_missing_target: 'tidas.flow.reference-property-unit.required',\n    same_category_high_similarity: 'tidas.flow.identity.alias-equivalence.review',\n  },\n  'flow-publish/default': {\n    flow_schema_failed: 'tidas.flow.evidence.field-bindings.required',\n  },\n  'flow-dedup/default': {\n    same_property_semantic_review: 'tidas.flow.identity.alias-equivalence.review',\n  },\n};\n\nexport function listRuntimeRulesets(): RuntimeRuleset[] {\n  return RULESETS.map((ruleset) => ({ ...ruleset, rule_ids: [...ruleset.rule_ids] }));\n}\n\nexport function getRuntimeRuleset<T extends RuntimeRulesetId>(id: T): RuntimeRuleset & { id: T } {\n  const ruleset = RULESETS_BY_ID[id];\n  return { ...ruleset, rule_ids: [...ruleset.rule_ids] } as RuntimeRuleset & { id: T };\n}\n\nexport function getRuntimeRule(id: string): RuntimeRule | null {\n  const rule = RULES_BY_ID[id];\n  return rule ? { ...rule, phases: [...rule.phases] } : null;\n}\n\nexport function runtimeRuleIds(id: RuntimeRulesetId): string[] {\n  return getRuntimeRuleset(id).rule_ids;\n}\n\nexport function resolveRuntimeRuleId(\n  rulesetId: RuntimeRulesetId,\n  localRuleId: string | null | undefined,\n): string | null {\n  if (!localRuleId) {\n    return null;\n  }\n  return LOCAL_RULE_ID_MAP[rulesetId]?.[localRuleId] ?? null;\n}\n\nexport function isRuntimeRuleBlocker(ruleId: string | null | undefined): boolean {\n  if (!ruleId) {\n    return false;\n  }\n  return RULES_BY_ID[ruleId]?.default_blocker ?? false;\n}\n"]}

package/dist/src/lib/tidas-sdk-package-validator.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import path from 'node:path';
+import { validateSchemaWithDeepFallback, } from './tidas-sdk-validation.js';
 const SUPPORTED_CATEGORIES = [
     'contacts',
     'flowproperties',
@@ -20,6 +21,16 @@ const CATEGORY_SCHEMA_EXPORTS = {
     sources: 'SourceSchema',
     unitgroups: 'UnitGroupSchema',
 };
+const CATEGORY_FACTORY_EXPORTS = {
+    contacts: 'createContact',
+    flowproperties: 'createFlowProperty',
+    flows: 'createFlow',
+    lciamethods: 'createLCIAMethod',
+    lifecyclemodels: 'createLifeCycleModel',
+    processes: 'createProcess',
+    sources: 'createSource',
+    unitgroups: 'createUnitGroup',
+};
 const CHINESE_CHARACTER_RE = /[\u3400-\u4DBF\u4E00-\u9FFF\uF900-\uFAFF]/u;
 function summarizeIssues(issues) {
     const errorCount = issues.filter((issue) => issue.severity === 'error').length;
@@ -375,13 +386,13 @@ function collectClassificationIssues(jsonItem, category, filePath) {
     }
     return issues;
 }
-function collectSchemaIssues(schema, jsonItem, category, filePath) {
+function collectSchemaIssues(schema, jsonItem, category, filePath, createEntity = null) {
     try {
-        const result = schema.safeParse(jsonItem);
+        const result = validateSchemaWithDeepFallback(schema, jsonItem, createEntity);
         if (result.success) {
             return [];
         }
-        const rawIssues = Array.isArray(result.error?.issues) ? result.error.issues : [];
+        const rawIssues = result.issues;
         if (rawIssues.length === 0) {
             return [createValidationErrorIssue(category, filePath, 'Schema validation failed')];
         }
@@ -391,7 +402,7 @@ function collectSchemaIssues(schema, jsonItem, category, filePath) {
         return [createValidationErrorIssue(category, filePath, error)];
     }
 }
-function categoryValidate(jsonFilePath, category, schema, emitLogs = true) {
+function categoryValidate(jsonFilePath, category, schema, createEntity = null, emitLogs = true) {
     const issues = [];
     for (const fileName of readdirSync(jsonFilePath).sort()) {
         if (!fileName.endsWith('.json')) {
@@ -407,7 +418,7 @@ function categoryValidate(jsonFilePath, category, schema, emitLogs = true) {
             continue;
         }
         const itemIssues = dedupeIssues([
-            ...collectSchemaIssues(schema, jsonItem, category, fullPath),
+            ...collectSchemaIssues(schema, jsonItem, category, fullPath, createEntity),
             ...collectFlowSchemaGapIssues(jsonItem, category, fullPath),
             ...collectLocalizedTextIssues(jsonItem, category, fullPath),
             ...collectClassificationIssues(jsonItem, category, fullPath),
@@ -440,7 +451,12 @@ function resolveCategorySchemas(moduleExports) {
         if (!isSafeParseSchema(schema)) {
             return null;
         }
-        schemas.set(category, schema);
+        const factoryName = CATEGORY_FACTORY_EXPORTS[category];
+        const createEntity = moduleExports[factoryName];
+        schemas.set(category, {
+            schema,
+            createEntity: typeof createEntity === 'function' ? createEntity : null,
+        });
     }
     return schemas;
 }
@@ -454,11 +470,13 @@ export function createTidasSdkPackageValidator(moduleExports, location) {
         validatePackageDir(inputDir, emitLogs = false) {
             const categoryReports = SUPPORTED_CATEGORIES.flatMap((category) => {
                 const categoryDir = path.join(inputDir, category);
-                const schema = schemas.get(category);
-                if (!schema || !existsSync(categoryDir)) {
+                const validator = schemas.get(category);
+                if (!validator || !existsSync(categoryDir)) {
                     return [];
                 }
-                return [categoryValidate(categoryDir, category, schema, emitLogs)];
+                return [
+                    categoryValidate(categoryDir, category, validator.schema, validator.createEntity, emitLogs),
+                ];
             });
             return buildPackageReport(inputDir, categoryReports);
         },
@@ -488,6 +506,7 @@ export const __testInternals = {
     collectClassificationIssues,
     collectSchemaIssues,
     categoryValidate,
+    CATEGORY_FACTORY_EXPORTS,
     resolveCategorySchemas,
 };
 //# sourceMappingURL=tidas-sdk-package-validator.js.map