@devtrack-solution/codesdd 1.2.2

package/dist/core/sdd/types.js

@@ -0,0 +1,617 @@
+import { z } from 'zod';
+// Core ID patterns
+export const ID_PATTERNS = {
+    insight: /^INS-\d{3,}$/,
+    debate: /^DEB-\d{3,}$/,
+    radar: /^RAD-\d{3,}$/,
+    epic: /^EPIC-\d{3,}$/,
+    /** Matches both RAD-### (legacy) and EPIC-#### (canonical) */
+    epicOrRadar: /^(?:RAD|EPIC)-\d{3,}$/,
+    feature: /^FEAT-\d{3,}$/,
+    frontendGap: /^FGAP-\d{3,}$/,
+    techDebt: /^TD-\d{3,}$/,
+};
+export const OriginTypeSchema = z.enum([
+    'radar',
+    'epic',
+    'direct',
+    'fast_track',
+    'frontend_gap',
+    'tech_debt',
+]);
+export const ScaleSchema = z.enum(['QUICK', 'STANDARD', 'LARGE']);
+export const ExecutionKindSchema = z.enum([
+    'feature',
+    'infra',
+    'migration',
+    'frontend_coverage',
+    'documentation',
+]);
+export const PlanningModeSchema = z.enum(['local_plan', 'direct_tasks']);
+export const FlowModeSchema = z.enum(['direto', 'padrao', 'rigoroso']);
+export const FlowStageSchema = z.enum(['proposta', 'planejamento', 'tarefas', 'execucao', 'consolidacao']);
+export const GateStatusSchema = z.enum(['nao_exigida', 'rascunho', 'pronta', 'aprovada']);
+export const SourceDocumentTypeSchema = z.enum([
+    'prd',
+    'rfc',
+    'briefing',
+    'historia',
+    'wireframe',
+    'html_mock',
+    'referencia_visual',
+    'entrevista',
+    'anexo',
+    'legado',
+    'outro',
+]);
+export const SourceDocumentStatusSchema = z.enum([
+    'RAW',
+    'INDEXED',
+    'NORMALIZED',
+    'PLANNED',
+    'ARCHIVED',
+]);
+export const SourceAuthoritySchema = z.enum([
+    'official',
+    'regulator',
+    'legislation',
+    'standard',
+    'vendor',
+    'community',
+    'internal',
+    'unknown',
+]);
+export const SourceClassificationSchema = z.enum([
+    'law',
+    'regulation',
+    'official_guidance',
+    'administrative_decision',
+    'jurisprudence',
+    'technical_best_practice',
+    'other',
+]);
+export const SourceVerificationStatusSchema = z.enum(['verified', 'stale', 'unverified', 'needs_review']);
+export const DiscoveryTypeSchema = z.enum(['INS', 'DEB', 'RAD', 'EPIC']);
+export const DiscoveryStatusSchema = z.enum([
+    'NEW',
+    'DEBATED',
+    'PROMOTED',
+    'DROPPED',
+    'OPEN',
+    'APPROVED',
+    'DISCARDED',
+    'SUPERSEDED',
+    'READY',
+    'PLANNED',
+    'SPLIT',
+    'IN_PROGRESS',
+    'DONE',
+    'CANCELLED',
+]);
+export const BacklogStatusSchema = z.enum([
+    'READY',
+    'BLOCKED',
+    'IN_PROGRESS',
+    'SYNC_REQUIRED',
+    'VERIFY_FAILED',
+    'ARCHIVED',
+    'DONE',
+]);
+export const FrontendGapStatusSchema = z.enum([
+    'OPEN',
+    'PLANNED',
+    'IN_PROGRESS',
+    'DONE',
+    'SUPERSEDED',
+]);
+export const FrontendImpactStatusSchema = z.enum(['unknown', 'none', 'required']);
+export const FrontendGapOriginKindSchema = z.enum(['manual', 'automatic']);
+export const FrontendGapDetectionSourceSchema = z.enum(['metadata', 'diff', 'manual']);
+export const QualityEvidenceStatusSchema = z.enum(['planned', 'provided', 'waived']);
+export const QualityEvidenceModeSchema = z.enum(['coverage', 'equivalence', 'hybrid']);
+export const QualityEnforcementSchema = z.enum(['advisory', 'blocking']);
+export const FrontendUiStatusSchema = z.enum([
+    'OK',
+    'GAP',
+    'PLANNED',
+    'PARTIAL',
+    'DEPRECATED',
+]);
+export const TechDebtStatusSchema = z.enum(['OPEN', 'IN_PROGRESS', 'DONE']);
+const NullableStringSchema = z.string().optional();
+const StringArraySchema = z.array(z.string()).default([]);
+export const QualityEvidenceSchema = z.object({
+    kind: z.string().min(1),
+    required: z.boolean().default(true),
+    status: QualityEvidenceStatusSchema.default('planned'),
+    command: NullableStringSchema,
+    artifact: NullableStringSchema,
+    notes: NullableStringSchema,
+});
+export const QualityExceptionSchema = z.object({
+    id: z.string().min(1),
+    scope: z.string().min(1),
+    reason: z.string().min(1),
+    accepted_risk: z.string().min(1),
+    compensating_control: z.string().min(1),
+    review_deadline: z.string().min(1),
+    approved_by: z.string().min(1),
+    approved_at: NullableStringSchema,
+});
+export const QualityContractSchema = z.object({
+    version: z.literal(1).default(1),
+    enabled: z.boolean().default(true),
+    inherited_from: NullableStringSchema,
+    scope: z.string().default('touched_scope'),
+    unit_target_percent: z.number().min(0).max(100).default(95),
+    integration_target_percent: z.number().min(0).max(100).default(95),
+    evidence_mode: QualityEvidenceModeSchema.default('hybrid'),
+    enforcement: QualityEnforcementSchema.default('blocking'),
+    stack_profile: z.string().default('default'),
+    required_axes: StringArraySchema,
+    required_evidence: z.array(QualityEvidenceSchema).default([]),
+    exceptions: z.array(QualityExceptionSchema).default([]),
+    updated_at: NullableStringSchema,
+});
+const StageGateSchema = z.object({
+    status: GateStatusSchema.default('rascunho'),
+    approved_at: NullableStringSchema,
+    approved_by: NullableStringSchema,
+    note: NullableStringSchema,
+});
+const BacklogGatesSchema = z.object({
+    proposta: StageGateSchema.default({ status: 'rascunho' }),
+    planejamento: StageGateSchema.default({ status: 'rascunho' }),
+    tarefas: StageGateSchema.default({ status: 'rascunho' }),
+});
+export const DiscoveryRecordSchema = z
+    .object({
+    id: z.string().min(1),
+    type: DiscoveryTypeSchema,
+    title: z.string().min(1),
+    title_canonical: z.string().min(1).max(60).optional(),
+    status: DiscoveryStatusSchema,
+    origin_prompt: NullableStringSchema,
+    related_ids: StringArraySchema,
+    warning_links: StringArraySchema,
+    created_at: NullableStringSchema,
+    updated_at: NullableStringSchema,
+    quality_contract: QualityContractSchema.optional(),
+})
+    .superRefine((record, ctx) => {
+    // EPIC and RAD are interchangeable during transition; both prefixes are valid for type EPIC or RAD
+    const validPrefixes = record.type === 'EPIC' || record.type === 'RAD'
+        ? ['RAD-', 'EPIC-']
+        : [`${record.type}-`];
+    if (!validPrefixes.some((prefix) => record.id.startsWith(prefix))) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Discovery record id "${record.id}" must start with one of: ${validPrefixes.join(', ')}`,
+        });
+    }
+});
+export const BacklogItemSchema = z
+    .object({
+    id: z.string().regex(ID_PATTERNS.feature, 'Invalid FEAT id format'),
+    title: z.string().min(1),
+    status: BacklogStatusSchema,
+    origin_type: OriginTypeSchema,
+    origin_ref: NullableStringSchema,
+    scale: ScaleSchema.default('STANDARD'),
+    summary: NullableStringSchema,
+    blocked_by: StringArraySchema,
+    touches: StringArraySchema,
+    lock_domains: StringArraySchema,
+    parallel_group: NullableStringSchema,
+    execution_kind: ExecutionKindSchema.default('feature'),
+    planning_mode: PlanningModeSchema.default('local_plan'),
+    flow_mode: FlowModeSchema.default('padrao'),
+    current_stage: FlowStageSchema.default('proposta'),
+    gates: BacklogGatesSchema.default({
+        proposta: { status: 'rascunho' },
+        planejamento: { status: 'rascunho' },
+        tarefas: { status: 'rascunho' },
+    }),
+    acceptance_refs: StringArraySchema,
+    produces: StringArraySchema,
+    consumes: StringArraySchema,
+    priority_score: z.number().default(0),
+    dependency_count: z.number().int().nonnegative().default(0),
+    agent_role: NullableStringSchema,
+    recommended_skills: StringArraySchema,
+    change_name: NullableStringSchema,
+    branch_name: NullableStringSchema,
+    worktree_path: NullableStringSchema,
+    start_commit_sha: NullableStringSchema,
+    requires_adr: z.boolean().default(false),
+    quality_contract: QualityContractSchema.optional(),
+    frontend_impact_status: FrontendImpactStatusSchema.default('unknown'),
+    frontend_impact_reason: NullableStringSchema,
+    frontend_impact_declared_at: NullableStringSchema,
+    frontend_surface_tokens: StringArraySchema,
+    frontend_gap_refs: StringArraySchema,
+    warning_links: StringArraySchema,
+    spec_refs: StringArraySchema,
+    last_sync_at: NullableStringSchema,
+    archived_at: NullableStringSchema,
+    done_at: NullableStringSchema,
+    unblocked_at: NullableStringSchema,
+})
+    .superRefine((item, ctx) => {
+    if (item.origin_type !== 'direct' && item.origin_type !== 'fast_track') {
+        if (!item.origin_ref || item.origin_ref.trim() === '') {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `BacklogItem origin_ref cannot be empty when origin_type is '${item.origin_type}'`,
+            });
+        }
+        else if (item.origin_type === 'epic' || item.origin_type === 'radar') {
+            if (!ID_PATTERNS.epicOrRadar.test(item.origin_ref)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `BacklogItem origin_ref "${item.origin_ref}" does not match EPIC/RAD prefix required for origins epic/radar`,
+                });
+            }
+        }
+    }
+});
+export const TechDebtRecordSchema = z.object({
+    id: z.string().regex(ID_PATTERNS.techDebt, 'Invalid TD id format'),
+    title: z.string().min(1),
+    status: TechDebtStatusSchema.default('OPEN'),
+    description: NullableStringSchema,
+    related_refs: StringArraySchema,
+    created_at: NullableStringSchema,
+    updated_at: NullableStringSchema,
+});
+export const FinalizeQueueItemSchema = z.object({
+    feature_id: z.string().regex(ID_PATTERNS.feature, 'Invalid FEAT id format'),
+    status: z.enum(['PENDING', 'DONE']).default('PENDING'),
+    summary: NullableStringSchema,
+    created_at: NullableStringSchema,
+    completed_at: NullableStringSchema,
+});
+export const UnblockEventSchema = z.object({
+    feature_id: z.string().regex(ID_PATTERNS.feature, 'Invalid FEAT id format'),
+    unblocked_by: z.string().regex(ID_PATTERNS.feature, 'Invalid FEAT id format'),
+    created_at: NullableStringSchema,
+    status: z.enum(['NEW', 'SEEN']).default('NEW'),
+});
+export const TransitionLogEventSchema = z.object({
+    entity_type: z.string().min(1),
+    entity_id: z.string().min(1),
+    from: z.string().min(1),
+    to: z.string().min(1),
+    actor: z.string().min(1),
+    reason: NullableStringSchema,
+    timestamp: z.string().min(1),
+    source_command: z.string().min(1),
+    force_transition: z.boolean().default(false),
+    lens_violations: StringArraySchema,
+});
+export const SkillCatalogEntrySchema = z.object({
+    id: z.string().min(1),
+    source_repo: NullableStringSchema,
+    source_path: NullableStringSchema,
+    title: z.string().min(1),
+    description: NullableStringSchema,
+    phases: StringArraySchema,
+    domains: StringArraySchema,
+    tools: StringArraySchema,
+    bundle_ids: StringArraySchema,
+    priority: z.number().int().nonnegative().default(0),
+});
+export const SkillBundleSchema = z.object({
+    id: z.string().min(1),
+    title: z.string().min(1),
+    skill_ids: StringArraySchema,
+});
+export const SkillRoutingRuleSchema = z.object({
+    domain: z.string().min(1),
+    skills: StringArraySchema,
+    bundles: StringArraySchema,
+});
+export const SkillRoutingStateSchema = z.object({
+    version: z.literal(1),
+    default_skills: StringArraySchema,
+    routes: z.array(SkillRoutingRuleSchema).default([]),
+});
+export const SourceDocumentRecordSchema = z.object({
+    id: z.string().min(1),
+    type: SourceDocumentTypeSchema,
+    path: z.string().min(1),
+    title: z.string().min(1),
+    status: SourceDocumentStatusSchema.default('RAW'),
+    source_version: z.number().int().positive().default(1),
+    source_fingerprint: NullableStringSchema,
+    authority: SourceAuthoritySchema.default('unknown'),
+    source_url: NullableStringSchema,
+    source_classification: SourceClassificationSchema.default('other'),
+    jurisdiction_tags: StringArraySchema,
+    last_verified_at: NullableStringSchema,
+    verification_status: SourceVerificationStatusSchema.default('unverified'),
+    verification_notes: NullableStringSchema,
+    legal_validation_required: z.boolean().default(false),
+    summary: NullableStringSchema,
+    imported_at: NullableStringSchema,
+    updated_at: NullableStringSchema,
+    used_by: StringArraySchema,
+    notes: StringArraySchema,
+    consolidation_targets: StringArraySchema,
+});
+export const SourceVersionEventSchema = z.object({
+    id: z.string().min(1),
+    source_id: z.string().min(1),
+    version: z.number().int().positive(),
+    changed_at: z.string().min(1),
+    reason: z.string().min(1),
+    actor: z.string().min(1).default('codesdd'),
+    summary: NullableStringSchema,
+});
+export const JurisdictionProfileSchema = z.object({
+    id: z.string().min(1),
+    title: z.string().min(1),
+    jurisdiction: z.string().min(1),
+    status: z.enum(['active', 'proposed', 'deprecated']).default('active'),
+    summary: NullableStringSchema,
+    applicability: NullableStringSchema,
+    tags: StringArraySchema,
+    source_refs: StringArraySchema,
+    updated_at: NullableStringSchema,
+});
+export const ControlCatalogItemSchema = z.object({
+    id: z.string().min(1),
+    title: z.string().min(1),
+    category: z.string().min(1),
+    severity: z.enum(['low', 'medium', 'high', 'critical']).default('medium'),
+    automatable: z.enum(['yes', 'partial', 'no']).default('partial'),
+    verification_types: StringArraySchema,
+    jurisdiction_profile_ids: StringArraySchema,
+    source_refs: StringArraySchema,
+    legal_validation_required: z.boolean().default(false),
+    updated_at: NullableStringSchema,
+});
+export const ArchitectureNodeSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    kind: z.string().min(1),
+    description: NullableStringSchema,
+    repo_paths: StringArraySchema,
+    depends_on: StringArraySchema,
+});
+export const ServiceRecordSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    responsibility: NullableStringSchema,
+    owner_refs: StringArraySchema,
+    repo_paths: StringArraySchema,
+    contracts: StringArraySchema,
+    external_dependencies: StringArraySchema,
+});
+export const TechStackRecordSchema = z.object({
+    layer: z.string().min(1),
+    technology: z.string().min(1),
+    version: NullableStringSchema,
+    purpose: NullableStringSchema,
+    constraints: StringArraySchema,
+});
+export const FrontendDecisionRecordSchema = z.object({
+    id: z.string().min(1),
+    title: z.string().min(1),
+    status: z.enum(['PROPOSED', 'APPROVED', 'DISCARDED', 'SUPERSEDED']).default('PROPOSED'),
+    decision: NullableStringSchema,
+    rationale: NullableStringSchema,
+    related_refs: StringArraySchema,
+    route_refs: StringArraySchema,
+    adr_refs: StringArraySchema,
+});
+export const RepoMapRecordSchema = z.object({
+    path: z.string().min(1),
+    kind: z.string().min(1),
+    service_ref: NullableStringSchema,
+    notes: NullableStringSchema,
+});
+export const FrontendGapRecordSchema = z.object({
+    id: z.string().regex(ID_PATTERNS.frontendGap, 'Invalid FGAP id format'),
+    title: z.string().min(1),
+    status: FrontendGapStatusSchema,
+    origin_kind: FrontendGapOriginKindSchema.default('manual'),
+    detection_sources: z.array(FrontendGapDetectionSourceSchema).default([]),
+    origin_feature: NullableStringSchema,
+    backend_refs: StringArraySchema,
+    frontend_scope: NullableStringSchema,
+    route_targets: StringArraySchema,
+    menu_targets: StringArraySchema,
+    suggested_files: StringArraySchema,
+    implemented_files: StringArraySchema,
+    resolved_by_feature: NullableStringSchema,
+    related_route_ids: StringArraySchema,
+    notes: NullableStringSchema,
+    created_at: NullableStringSchema,
+    updated_at: NullableStringSchema,
+});
+export const FrontendRouteRecordSchema = z.object({
+    id: z.string().min(1),
+    path: z.string().min(1),
+    parent_id: NullableStringSchema,
+    label: NullableStringSchema,
+    nav_surface: NullableStringSchema,
+    ui_status: FrontendUiStatusSchema,
+    source_gap_ids: StringArraySchema,
+    implemented_files: StringArraySchema,
+    notes: NullableStringSchema,
+});
+export const DiscoveryIndexStateSchema = z.object({
+    version: z.literal(1),
+    counters: z
+        .object({
+        INS: z.number().int().nonnegative().default(0),
+        DEB: z.number().int().nonnegative().default(0),
+        RAD: z.number().int().nonnegative().default(0),
+        EPIC: z.number().int().nonnegative().default(0),
+        FEAT: z.number().int().nonnegative().default(0),
+        FGAP: z.number().int().nonnegative().default(0),
+        TD: z.number().int().nonnegative().default(0),
+    })
+        .default({ INS: 0, DEB: 0, RAD: 0, EPIC: 0, FEAT: 0, FGAP: 0, TD: 0 }),
+    records: z.array(DiscoveryRecordSchema).default([]),
+});
+export const BacklogStateSchema = z.object({
+    version: z.literal(1),
+    items: z.array(BacklogItemSchema).default([]),
+});
+export const TechDebtStateSchema = z.object({
+    version: z.literal(1),
+    items: z.array(TechDebtRecordSchema).default([]),
+});
+export const FinalizeQueueStateSchema = z.object({
+    version: z.literal(1),
+    items: z.array(FinalizeQueueItemSchema).default([]),
+});
+export const UnblockEventsStateSchema = z.object({
+    version: z.literal(1),
+    events: z.array(UnblockEventSchema).default([]),
+});
+export const TransitionLogStateSchema = z.object({
+    version: z.literal(1),
+    events: z.array(TransitionLogEventSchema).default([]),
+});
+const AuditHistoryMetricSchema = z.object({
+    ok: z.number().int().nonnegative(),
+    total: z.number().int().nonnegative(),
+    percent: z.number(),
+});
+export const AuditHistoryEntrySchema = z.object({
+    run_id: z.string().min(1),
+    generated_at: z.string().min(1),
+    score: z.number(),
+    healthy: z.boolean(),
+    should_open_insight: z.boolean(),
+    metrics: z.object({
+        artifacts_without_placeholder: AuditHistoryMetricSchema,
+        debates_with_real_deliberation: AuditHistoryMetricSchema,
+        adrs_generated_vs_expected: AuditHistoryMetricSchema,
+        quality_contracts_ready: AuditHistoryMetricSchema,
+        forced_transitions: z.object({
+            total: z.number().int().nonnegative(),
+            feature_refs: StringArraySchema,
+        }),
+    }),
+    recommendation: z.string(),
+});
+export const AuditHistoryStateSchema = z.object({
+    version: z.literal(1),
+    runs: z.array(AuditHistoryEntrySchema).default([]),
+});
+export const SkillCatalogStateSchema = z.object({
+    version: z.literal(1),
+    skills: z.array(SkillCatalogEntrySchema).default([]),
+    bundles: z.array(SkillBundleSchema).default([]),
+});
+export const SourceIndexStateSchema = z.object({
+    version: z.literal(1),
+    sources: z.array(SourceDocumentRecordSchema).default([]),
+    version_events: z.array(SourceVersionEventSchema).default([]),
+    jurisdiction_profiles: z.array(JurisdictionProfileSchema).default([]),
+    control_catalog: z.array(ControlCatalogItemSchema).default([]),
+});
+export const FrontendGapsStateSchema = z.object({
+    version: z.literal(1),
+    items: z.array(FrontendGapRecordSchema).default([]),
+});
+export const FrontendMapStateSchema = z.object({
+    version: z.literal(1),
+    routes: z.array(FrontendRouteRecordSchema).default([]),
+});
+export const ArchitectureStateSchema = z.object({
+    version: z.literal(1),
+    nodes: z.array(ArchitectureNodeSchema).default([]),
+});
+export const ServiceCatalogStateSchema = z.object({
+    version: z.literal(1),
+    services: z.array(ServiceRecordSchema).default([]),
+});
+export const TechStackStateSchema = z.object({
+    version: z.literal(1),
+    items: z.array(TechStackRecordSchema).default([]),
+});
+export const IntegrationContractsStateSchema = z.object({
+    version: z.literal(1),
+    contracts: z.array(z.string()).default([]),
+});
+export const FrontendDecisionsStateSchema = z.object({
+    version: z.literal(1),
+    items: z.array(FrontendDecisionRecordSchema).default([]),
+});
+export const RepoMapStateSchema = z.object({
+    version: z.literal(1),
+    items: z.array(RepoMapRecordSchema).default([]),
+});
+export const NamingContractTermScopeSchema = z.enum(['code', 'docs', 'state', 'all']);
+export const NamingContractTermSeveritySchema = z.enum(['error', 'warning']);
+export const NamingContractForbiddenTermSchema = z.object({
+    term: z.string().min(1),
+    scope: NamingContractTermScopeSchema.default('all'),
+    severity: NamingContractTermSeveritySchema.default('warning'),
+    allowlist_paths: z.array(z.string()).default([]),
+});
+export const NamingContractAllowlistEntrySchema = z.object({
+    path_pattern: z.string().min(1),
+    reason: z.string().min(1),
+    expires_at: z.string().optional(),
+    owner: z.string().min(1),
+});
+export const NamingContractIdentitySchema = z.object({
+    product_name: z.string().min(1),
+    cli_bin: z.string().min(1),
+    package_name: z.string().min(1),
+});
+export const NamingContractRenameRuleStatusSchema = z.enum([
+    'planned',
+    'in_progress',
+    'done',
+]);
+export const NamingContractRenameRuleSchema = z.object({
+    from: z.string().min(1),
+    to: z.string().min(1),
+    scope: NamingContractTermScopeSchema.default('all'),
+    phase: z.string().min(1),
+    owner: z.string().min(1),
+    status: NamingContractRenameRuleStatusSchema.default('planned'),
+    path_globs: z.array(z.string().min(1)).default([]),
+});
+export const NamingContractZeroResidueGateSchema = z.object({
+    enabled: z.boolean().default(false),
+    enforcement: NamingContractTermSeveritySchema.default('warning'),
+    terms: z.array(z.string().min(1)).default([]),
+    allowlist_paths: z.array(z.string().min(1)).default([]),
+    removal_phase: z.string().min(1).default('compatibility-shutdown'),
+});
+export const NamingContractStateSchema = z.object({
+    version: z.literal(1).default(1),
+    product_name: z.string().min(1).default('CodeSDD'),
+    cli_bin: z.string().min(1).default('codesdd'),
+    package_name: z.string().min(1).default('@devtrack-solution/codesdd'),
+    current_identity: NamingContractIdentitySchema.default({
+        product_name: 'CodeSDD',
+        cli_bin: 'codesdd',
+        package_name: '@devtrack-solution/codesdd',
+    }),
+    target_identity: NamingContractIdentitySchema.default({
+        product_name: 'CodeSDD',
+        cli_bin: 'codesdd',
+        package_name: '@devtrack-solution/codesdd',
+    }),
+    forbidden_terms: z.array(NamingContractForbiddenTermSchema).default([]),
+    allowlist: z.array(NamingContractAllowlistEntrySchema).default([]),
+    rename_rules: z.array(NamingContractRenameRuleSchema).default([]),
+    zero_residue_gate: NamingContractZeroResidueGateSchema.default({
+        enabled: false,
+        enforcement: 'warning',
+        terms: [],
+        allowlist_paths: [],
+        removal_phase: 'compatibility-shutdown',
+    }),
+    updated_at: NullableStringSchema,
+});
+//# sourceMappingURL=types.js.map

package/dist/core/sdd/views.d.ts

@@ -0,0 +1,3 @@
+import type { SddPaths, SddRuntimeConfig, SddStateSnapshot } from './state.js';
+export declare function renderViews(paths: SddPaths, config: SddRuntimeConfig, state: SddStateSnapshot): Promise<void>;
+//# sourceMappingURL=views.d.ts.map