agentic-mermaid 0.4.1 → 0.5.3

package/dist/agent-core.d.ts

@@ -1,66 +1,129 @@
-import { P as ParsedDiagram, d7 as Result, cl as ParseError, es as ValidDiagramPayload, eq as ValidDiagram, aP as ExtensionDiagramBody, c5 as MutationError, fV as Direction, bv as FlowchartMutationOp, bw as FlowchartValidDiagram, dP as StateMutationOp, dS as StateValidDiagram, dE as SequenceMutationOp, dG as SequenceValidDiagram, ee as TimelineMutationOp, eh as TimelineValidDiagram, a7 as ClassMutationOp, ac as ClassValidDiagram, aL as ErMutationOp, aN as ErValidDiagram, bM as JourneyMutationOp, bP as JourneyValidDiagram, n as ArchitectureMutationOp, q as ArchitectureValidDiagram, eD as XyChartMutationOp, eF as XyChartValidDiagram, co as PieMutationOp, cq as PieValidDiagram, cJ as QuadrantMutationOp, cL as QuadrantValidDiagram, bB as GanttMutationOp, bE as GanttValidDiagram, c2 as MindmapMutationOp, c3 as MindmapValidDiagram, bG as GitGraphMutationOp, bH as GitGraphValidDiagram, cV as RadarMutationOp, cW as RadarValidDiagram, aA as DiagramKind, f as AnyMutationOp, c4 as MutableValidDiagram, fW as MermaidEdge, eu as VerifyResult, et as VerifyOptions, d0 as RenderedLayout, bQ as LayoutRouteCertificate, bd as FamilyConformanceReport, bf as FamilyDescriptor, bi as FamilyId, fX as PositionedDiagram, bm as FamilyPositionedProjectionOptions, bn as FamilyPositionedView, d4 as RenderedRegionKind, fY as TerminalProjectionDiagnosticCode, D as DiagramActionRecord, A as AsciiRenderOptions, ay as DiagramAnalysis, R as RenderOptions, b as RenderRequestReceipt, fZ as renderMermaidASCII$1, c$ as RenderedAscii, f_ as renderMermaidSVG$1, f$ as RenderedSvg } from './index-BGA_-6LV.js';
-export { e as Accessibility, g as AnyPort, h as ArchitectureBody, i as ArchitectureEdge, j as ArchitectureEndpoint, k as ArchitectureEndpointBoundary, l as ArchitectureGroup, m as ArchitectureJunction, o as ArchitectureService, p as ArchitectureSide, r as ArchitectureVisualOverrides, s as AsciiRenderColorMode, t as AsciiWidthError, u as AsciiWidthErrorReason, B as BACKEND_CONFORMANCE_CHECK_IDS, v as BACKEND_CONFORMANCE_FIXTURE_ID, w as BACKEND_CONFORMANCE_VERSION, x as BINDABLE_ROLE_STYLE_PROPERTIES, y as BINDABLE_SCENE_ROLES, z as BRAND_CONSTRAINT_DESCRIPTORS, C as BRAND_CONSTRAINT_KINDS, E as BUILTIN_FAMILY_METADATA, F as BUILTIN_FAMILY_METADATA_COVERS_DIAGRAM_KIND, G as BUILTIN_SCENE_ROLE_TRAITS, I as BackendCapabilityConformanceResult, J as BackendCapabilityConformanceStatus, K as BackendConformanceCheck, L as BackendConformanceCheckId, M as BackendConformanceReport, N as BackendDescriptor, O as BackendRegistrationOptions, Q as BindableSceneRole, S as BrandConstraint, T as BrandConstraintAction, U as BrandConstraintKind, V as BuiltinFamilyId, W as BuiltinFamilyMetadata, X as CAPABILITY_NEGOTIATION_VERSION, Y as CORE_CAPABILITY_OFFERS, Z as CORE_SCENE_FEATURES, _ as CORE_SCENE_OPERATIONS, $ as CORE_SCENE_PRIMITIVES, a0 as CapabilityDecision, a1 as CapabilityId, a2 as CapabilityOffer, a3 as CapabilityRequirement, a4 as CapabilityRequirementLevel, a5 as CapabilityResolution, a6 as ClassBody, a8 as ClassNode, a9 as ClassNote, aa as ClassRelation, ab as ClassRelationKind, ad as CliRenderTransport, ae as CodeModeRenderTransport, af as ConnectorContourSemantics, ag as ConnectorEndpoints, ah as ConnectorGeometry, ai as ConnectorHitGeometry, aj as ConnectorLabelDescriptor, ak as ConnectorMark, al as ConnectorRelationship, am as ConnectorRoute, an as ConnectorStroke, ao as ConnectorSubpath, ap as ConnectorTerminalLabelProjection, aq as ConnectorTerminalMarkerPlacement, ar as ConnectorTerminalMarkerProjection, as as ConnectorTerminalProjection, at as ConnectorTerminalStrokeLoss, au as DEFAULT_LABEL_CHAR_CAP, av as DefaultBackend, aw as DiagramActionKind, ax as DiagramActionSecurity, az as DiagramBody, aB as DiamondFacet, aC as EXACT_ROLE_STYLE_CONTRACT, aD as EXACT_STYLE_SCENE_ROLES, aE as EXTERNAL_SCENE_API_VERSION, aF as EdgeId, aG as EdgeRouteCertificate, aH as ErAttribute, aI as ErBody, aJ as ErCardinality, aK as ErEntity, aM as ErRelation, aO as ExactStyleSceneRole, aQ as ExtensionIdentity, aR as ExtensionValidDiagram, aS as ExternalFamilyId, aT as ExternalSceneConnector, aU as ExternalSceneConnectorGeometry, aV as ExternalSceneConnectorLabel, aW as ExternalSceneContainer, aX as ExternalSceneDataMark, aY as ExternalSceneDocument, aZ as ExternalSceneGeometry, a_ as ExternalSceneInput, a$ as ExternalSceneMarker, b0 as ExternalSceneNode, b1 as ExternalSceneNodeBase, b2 as ExternalSceneShape, b3 as ExternalSceneText, b4 as ExtractedLabel, b5 as FAMILY_CAPABILITY_COLUMNS, b6 as FAMILY_CONFORMANCE_MAX_EXAMPLE_BYTES, b7 as FAMILY_CONFORMANCE_VERSION, b8 as FAMILY_DESCRIPTOR_CONTRACT_VERSION, b9 as FamilyCapability, ba as FamilyCapabilityConformanceResult, bb as FamilyCapabilityEvidence, bc as FamilyCapabilityState, be as FamilyConformanceStatus, bg as FamilyDetectionDiagnostic, bh as FamilyEdgeRouteCertificate, bj as FamilyOperations, bk as FamilyParsedBody, bl as FamilyPositionedProjectionContext, bo as FamilyRouteCertificate, bp as FamilyScenePositivePrimitive, bq as FamilyScenePrimitiveApplicability, br as FamilyScenePrimitiveEvidence, bs as FamilySceneRolePrimitiveDeclaration, bt as FeedbackEdgeAnalysis, bu as Finite, bx as GanttBody, by as GanttBodySection, bz as GanttBodyTask, bA as GanttBodyTaskTag, bC as GanttScheduleAnalysisSummary, bD as GanttStatement, bF as GitGraphBody, bI as GroupId, bJ as HOSTED_FONT_RESOURCES, H as HostBackendPolicy, bK as InitDirective, bL as JourneyBody, bN as JourneySection, bO as JourneyTask, bR as LayoutRouteClass, bS as LayoutWarning, bT as LibraryRenderTransport, bU as MAX_HOSTED_PNG_BYTES, bV as MAX_HOSTED_PNG_PIXELS, bW as MAX_PNG_FONT_DIRECTORIES, bX as MAX_PNG_FONT_DIRECTORY_LENGTH, bY as MAX_PNG_PIXELS, bZ as MAX_PNG_RASTER_DIMENSION, b_ as MarkerDescriptor, b$ as MermaidFamilyClassification, c0 as MermaidFamilyDetectionError, c1 as MindmapBody, c6 as NATIVE_PNG_HOST_ONLY_OPTION_FIELDS, c7 as NATIVE_PNG_OUTPUT_POLICY_FIELDS, c8 as NativePngHostOnlyOptionField, c9 as NativePngOutputPolicyField, ca as NodeId, cb as PNG_DEFAULT_FONT_FAMILY, cc as PNG_DEFAULT_SCALE, cd as PNG_FONT_SOURCES, ce as PNG_NAPI_RUNTIME, cf as PNG_OUTPUT_OPTION_FIELDS, cg as PNG_OUTPUT_OPTION_FIELD_DESCRIPTORS, ch as PNG_OUTPUT_POLICY_VERSION, ci as PNG_WASM_RUNTIME, cj as PORTABLE_PNG_OUTPUT_OPTION_FIELDS, ck as PRIMITIVE_REALIZATIONS, cm as ParticipantId, cn as PieBody, cp as PieSlice, cr as PngFitTo, cs as PngFontSource, ct as PngOutputOptionField, cu as PngOutputOptionFieldDescriptor, cv as PngOutputOptionInputKind, cw as PngOutputOptionPolicyState, cx as PngOutputOptionReceiptState, cy as PngOutputOptionScope, a as PngOutputPolicyInput, cz as PngRasterDimensions, c as PngRuntimeProvenance, cA as PortSemanticRole, cB as PortSide, cC as PortablePngOutputOptionField, cD as PortablePngOutputOptions, cE as PreservedDiagramBody, cF as PreservedSourceSpans, cG as PreservedValidDiagram, cH as QuadrantAxis, cI as QuadrantBody, cK as QuadrantPoint, cM as RENDER_CONTRACT_VERSION, cN as RENDER_OUTPUTS, cO as RENDER_OUTPUT_DESCRIPTORS, cP as RESOURCE_MANIFEST, cQ as RESOURCE_MANIFEST_VERSION, cR as ROLE_STYLE_PROPERTY_DESCRIPTORS, cS as RadarBody, cT as RadarBodyAxis, cU as RadarBodyCurve, cX as RegionContainmentCertificate, cY as RenderCapabilityError, cZ as RenderOutputDescriptor, c_ as RenderOutputTransports, d1 as RenderedLayoutEdge, d2 as RenderedLayoutGroup, d3 as RenderedLayoutNode, d as RenderedRegion, d5 as ResolvedPngOutputPolicy, d6 as ResolvedTerminalOutputPolicy, d8 as RoleStyleFor, d9 as RoleStyleSpec, da as RoleStyles, db as RouteBlocker, dc as RouteCertificate, dd as RouteClass, de as RoutePortAssignment, df as SCENE_CONTRACT_VERSION, dg as SCENE_ROLE_DESCRIPTORS, dh as SCENE_VALIDATION_LIMITS, di as SCENE_VALIDATION_VERSION, dj as SEMANTIC_BINDING_CHANNELS, dk as SHARED_RENDER_OPTION_FIELDS, dl as STYLE_COLOR_TOKEN_DESCRIPTORS, dm as STYLE_SPEC_FIELD_DESCRIPTORS, dn as STYLE_SPEC_FORMAT_VERSION, dp as SceneDoc, dq as SceneNode, dr as SceneRole, ds as SceneValidationDiagnostic, dt as SceneValidationDiagnosticCode, du as SceneValidationError, dv as SceneValidationOptions, dw as SceneValidationResult, dx as SemanticBinding, dy as SemanticBindingChannel, dz as SemanticChannels, dA as SemanticSlots, dB as SequenceBody, dC as SequenceMessage, dD as SequenceMessageStyle, dF as SequenceParticipant, dH as SerializedFlowchartGraph, dI as SourceComment, dJ as SourceMap, dK as SourceMapSpans, dL as SourcePreservationReceipt, dM as SourceSpan, dN as SourceSpanPoint, dO as StateBody, dQ as StateNode, dR as StateTransition, dT as StyleBackend, dU as StyleBackendContext, dV as StyleColors, dW as StyleDescriptor, dX as StyleInput, dY as StyleReferenceResolution, dZ as StyleRegistrationOptions, d_ as StyleSpec, d$ as TERMINAL_BOUNDED_PADDING_X, e0 as TERMINAL_DEFAULT_BOX_BORDER_PADDING, e1 as TERMINAL_DEFAULT_PADDING_X, e2 as TERMINAL_DEFAULT_PADDING_Y, e3 as TERMINAL_OUTPUT_POLICY_VERSION, e4 as TEXT_MEASUREMENT_CONTRACT, e5 as TerminalOutputPolicyError, e6 as TerminalOutputPolicyInput, e7 as TextMeasurementContract, e8 as TextMeasurementInput, e9 as TextMeasurementResult, ea as Tier1WarningCode, eb as Tier2WarningCode, ec as TimelineBody, ed as TimelineEvent, ef as TimelinePeriod, eg as TimelineSection, ei as UNREGISTERED_FAMILY_CAPABILITY_STATES, ej as UPSTREAM_MERMAID_FAMILY_INDEX, ek as UpstreamFamilyDescriptor, el as UpstreamHeaderDescriptor, em as UpstreamHeaderMatch, en as UpstreamManifestDiff, eo as UpstreamMermaidFamilyIndex, ep as UpstreamMermaidManifest, er as ValidDiagramMeta, ev as WARNING_SEVERITY, ew as WARNING_TIER, ex as WarningCode, ey as WarningSeverity, ez as WarningTier, eA as XyChartAxis, eB as XyChartAxisSpec, eC as XyChartBody, eE as XyChartSeries, eG as asArchitecture, eH as asClass, eI as asEr, eJ as asFlowchart, eK as asGantt, eL as asGitGraph, eM as asJourney, eN as asMindmap, eO as asPie, eP as asQuadrant, eQ as asRadar, eR as asSequence, eS as asState, eT as asTimeline, eU as asXyChart, eV as assertHostedPngRasterBudget, eW as assertPngRasterBudget, eX as assertValidSceneDoc, eY as buildExternalScene, eZ as builtinFamilyMetadata, e_ as classifyMermaidFamilyFromFirstLine, e$ as createExtensionIdentity, f0 as declareFamilyScenePrimitiveEvidence, f1 as detectRegisteredFamilyFromFirstLine, f2 as effectiveFamilyCapabilityState, f3 as err, f4 as findUpstreamFamilyByHeader, f5 as getBackend, f6 as getFamily, f7 as getFamilyConformanceReport, f8 as getStyle, f9 as hostedFontResource, fa as inferBackend, fb as isBuiltinFamilyId, fc as isExternalFamilyId, fd as knownBackendDescriptors, fe as knownBuiltinFamilies, ff as knownFamilies, fg as knownStyleDescriptors, fh as knownStyles, fi as measureText, fj as measureTextWidth, fk as negotiateCapabilities, fl as negotiateRenderCapabilities, fm as normalizePortablePngBackground, fn as ok, fo as omitPngOutputOptions, fp as parseRegisteredMermaid, fq as parseSemVer, fr as pngNapiRuntimeProvenance, fs as pngOutputOptionsJsonSchema, ft as pngRasterDimensions, fu as prepareSvgForPngRasterization, fv as projectNativePngOutputPolicyInput, fw as projectPortablePngOutputOptions, fx as registerBackend, fy as registerStyle, fz as resolvePngOutputPolicy, fA as resolvePortablePngOutputPolicy, fB as resolveSceneRoleTraits, fC as resolveStyleReference, fD as resolveStyleStack, fE as resolveTerminalOutputPolicy, fF as runBackendConformance, fG as sceneRoleTraits, fH as semVerSatisfies, fI as sharedRenderOptionsJsonSchema, fJ as styleInputJsonSchema, fK as styleSpecJsonSchema, fL as svgIntrinsicDimensions, fM as terminalConnectorCapabilityClaims, fN as toFinite, fO as validatePrimitiveCapabilities, fP as validateResourceManifest, fQ as validateSceneDoc, fR as validateSerializableRenderOptions, fS as validateStyleSpec, fT as verifyNoExternalRefs, fU as verifyResourceBytes } from './index-BGA_-6LV.js';
+import { cj as RenderedRegionKind, e5 as TerminalProjectionDiagnosticCode, e6 as TerminalProjectionDiagnostic, D as DiagramActionRecord, a as ParsedDiagram, cn as Result, bQ as ParseError, au as DiagramAnalysis, bJ as MutationError, S as C4Variant, bc as FlowchartMutationOp, bd as FlowchartValidDiagram, cL as StateMutationOp, cO as StateValidDiagram, cz as SequenceMutationOp, cB as SequenceValidDiagram, cT as TimelineMutationOp, cW as TimelineValidDiagram, a4 as ClassMutationOp, a9 as ClassValidDiagram, aC as ErMutationOp, aE as ErValidDiagram, bv as JourneyMutationOp, by as JourneyValidDiagram, j as ArchitectureMutationOp, m as ArchitectureValidDiagram, dc as XyChartMutationOp, de as XyChartValidDiagram, bT as PieMutationOp, bV as PieValidDiagram, b$ as QuadrantMutationOp, c1 as QuadrantValidDiagram, bi as GanttMutationOp, bl as GanttValidDiagram, bG as MindmapMutationOp, bH as MindmapValidDiagram, bn as GitGraphMutationOp, bo as GitGraphValidDiagram, c8 as RadarMutationOp, c9 as RadarValidDiagram, J as C4MutationOp, Q as C4ValidDiagram, cr as SankeyMutationOp, cs as SankeyValidDiagram, bN as PacketMutationOp, bO as PacketValidDiagram, bA as KanbanMutationOp, bB as KanbanValidDiagram, cl as RequirementMutationOp, cm as RequirementValidDiagram, cY as TreemapMutationOp, cZ as TreemapValidDiagram, dh as ZenUMLMutationOp, dk as ZenUMLValidDiagram, aJ as EventModelingMutationOp, aK as EventModelingValidDiagram, bs as IshikawaMutationOp, bt as IshikawaValidDiagram, p as BlockMutationOp, q as BlockValidDiagram, aw as DiagramKind, c as AnyMutationOp, bI as MutableValidDiagram, d3 as VerifyResult, e7 as ZenUMLFragmentType, dg as ZenUMLBranch, M as C4Shape, G as C4Element, w as C4Boundary, K as C4Relationship, b0 as FamilyId, b4 as FamilyPositionedProjectionOptions, b5 as FamilyPositionedView, a$ as FamilyDescriptor, bP as PaintLayoutCertification, ce as RenderedLayout, d1 as ValidDiagramPayload, c$ as ValidDiagram, aM as ExtensionDiagramBody, d2 as VerifyOptions, R as RenderRequestReceipt } from './paint-certification-6rwQjIv_.js';
+export { A as Accessibility, d as ArchitectureBody, e as ArchitectureEdge, f as ArchitectureEndpoint, g as ArchitectureEndpointBoundary, h as ArchitectureGroup, i as ArchitectureJunction, k as ArchitectureService, l as ArchitectureSide, B as BUILTIN_FAMILY_METADATA, n as BUILTIN_FAMILY_METADATA_COVERS_DIAGRAM_KIND, o as BlockBody, r as BuiltinFamilyId, s as BuiltinFamilyMetadata, C as C4Argument, t as C4ArgumentInput, u as C4Body, x as C4BoundaryInput, y as C4BoundaryKind, z as C4Diagnostic, E as C4Direction, F as C4Directive, H as C4ElementInput, I as C4ElementKind, L as C4RelationshipInput, N as C4Statement, O as C4Style, U as CAPABILITY_NEGOTIATION_VERSION, V as CORE_CAPABILITY_OFFERS, W as CORE_SCENE_FEATURES, X as CORE_SCENE_OPERATIONS, Y as CORE_SCENE_PRIMITIVES, Z as CapabilityDecision, _ as CapabilityId, $ as CapabilityOffer, a0 as CapabilityRequirement, a1 as CapabilityRequirementLevel, a2 as CapabilityResolution, a3 as ClassBody, a5 as ClassNode, a6 as ClassNote, a7 as ClassRelation, a8 as ClassRelationKind, aa as CliRenderTransport, ab as CodeModeRenderTransport, ac as ConnectorContourSemantics, ad as ConnectorEndpoints, ae as ConnectorGeometry, af as ConnectorHitGeometry, ag as ConnectorLabelDescriptor, ah as ConnectorMark, ai as ConnectorRelationship, aj as ConnectorRoute, ak as ConnectorStroke, al as ConnectorSubpath, am as ConnectorTerminalLabelProjection, an as ConnectorTerminalMarkerPlacement, ao as ConnectorTerminalMarkerProjection, ap as ConnectorTerminalProjection, aq as ConnectorTerminalStrokeLoss, ar as DEFAULT_LABEL_CHAR_CAP, as as DiagramActionKind, at as DiagramActionSecurity, av as DiagramBody, ax as EdgeId, ay as ErAttribute, az as ErBody, aA as ErCardinality, aB as ErEntity, aD as ErRelation, aF as EventData, aG as EventFrame, aH as EventFrameType, aI as EventModelingBody, aL as EventSpecification, aN as ExtensionValidDiagram, aO as ExternalFamilyId, aP as ExtractedLabel, aQ as FAMILY_CAPABILITY_COLUMNS, aR as FAMILY_CONFORMANCE_MAX_EXAMPLE_BYTES, aS as FAMILY_CONFORMANCE_VERSION, aT as FAMILY_DESCRIPTOR_CONTRACT_VERSION, aU as FamilyCapability, aV as FamilyCapabilityConformanceResult, aW as FamilyCapabilityEvidence, aX as FamilyCapabilityState, aY as FamilyConformanceError, aZ as FamilyConformanceReport, a_ as FamilyConformanceStatus, b1 as FamilyOperations, b2 as FamilyParsedBody, b3 as FamilyPositionedProjectionContext, b6 as FamilyScenePositivePrimitive, b7 as FamilyScenePrimitiveApplicability, b8 as FamilyScenePrimitiveEvidence, b9 as FamilySceneRolePrimitiveDeclaration, ba as FeedbackEdgeAnalysis, bb as Finite, be as GanttBody, bf as GanttBodySection, bg as GanttBodyTask, bh as GanttBodyTaskTag, bj as GanttScheduleAnalysisSummary, bk as GanttStatement, bm as GitGraphBody, bp as GroupId, bq as InitDirective, br as IshikawaBody, bu as JourneyBody, bw as JourneySection, bx as JourneyTask, bz as KanbanBody, bC as LayoutWarning, bD as LibraryRenderTransport, bE as MarkerDescriptor, bF as MindmapBody, bK as NodeId, bL as PRIMITIVE_REALIZATIONS, bM as PacketBody, P as PaintLayoutCertificationError, bR as ParticipantId, bS as PieBody, bU as PieSlice, bW as PreservedDiagramBody, bX as PreservedSourceSpans, bY as PreservedValidDiagram, bZ as QuadrantAxis, b_ as QuadrantBody, c0 as QuadrantPoint, c2 as RENDER_CONTRACT_VERSION, c3 as RENDER_OUTPUTS, c4 as RENDER_OUTPUT_DESCRIPTORS, c5 as RadarBody, c6 as RadarBodyAxis, c7 as RadarBodyCurve, ca as RenderCapabilityError, cb as RenderOutputDescriptor, cc as RenderOutputTransports, cd as RenderedLabelBounds, cf as RenderedLayoutEdge, cg as RenderedLayoutGroup, ch as RenderedLayoutLabel, ci as RenderedLayoutNode, b as RenderedRegion, ck as RequirementBody, co as SHARED_RENDER_OPTION_FIELDS, cp as SankeyBody, cq as SankeyBodyLink, ct as SceneDoc, cu as SceneNode, cv as SemanticChannels, cw as SequenceBody, cx as SequenceMessage, cy as SequenceMessageStyle, cA as SequenceParticipant, cC as SerializedFlowchartGraph, cD as SourceComment, cE as SourceMap, cF as SourceMapSpans, cG as SourcePreservationReceipt, cH as SourceSpan, cI as SourceSpanPoint, cJ as StateBody, cK as StateFloatingNote, cM as StateNode, cN as StateTransition, cP as Tier1WarningCode, cQ as Tier2WarningCode, cR as TimelineBody, cS as TimelineEvent, cU as TimelinePeriod, cV as TimelineSection, cX as TreemapBody, c_ as UNREGISTERED_FAMILY_CAPABILITY_STATES, d0 as ValidDiagramMeta, d4 as WARNING_SEVERITY, d5 as WARNING_TIER, d6 as WarningCode, d7 as WarningSeverity, d8 as WarningTier, d9 as XyChartAxis, da as XyChartAxisSpec, db as XyChartBody, dd as XyChartSeries, df as ZenUMLBody, di as ZenUMLParticipant, dj as ZenUMLStatement, dl as asArchitecture, dm as asBlock, dn as asC4, dp as asClass, dq as asEr, dr as asEventModeling, ds as asFlowchart, dt as asGantt, du as asGitGraph, dv as asIshikawa, dw as asJourney, dx as asKanban, dy as asMindmap, dz as asPacket, dA as asPie, dB as asQuadrant, dC as asRadar, dD as asRequirement, dE as asSankey, dF as asSequence, dG as asState, dH as asTimeline, dI as asTreemap, dJ as asXyChart, dK as asZenUML, dL as builtinFamilyMetadata, dM as declareFamilyScenePrimitiveEvidence, dN as detectRegisteredFamilyFromFirstLine, dO as effectiveFamilyCapabilityState, dP as err, dQ as getFamily, dR as getFamilyConformanceReport, dS as isBuiltinFamilyId, dT as isExternalFamilyId, dU as knownBuiltinFamilies, dV as knownFamilies, dW as negotiateCapabilities, dX as negotiateRenderCapabilities, dY as ok, dZ as parseSemVer, d_ as semVerSatisfies, d$ as sharedRenderOptionsJsonSchema, e0 as styleInputJsonSchema, e1 as terminalConnectorCapabilityClaims, e2 as toFinite, e3 as validatePrimitiveCapabilities, e4 as validateSerializableRenderOptions, v as verifyNoExternalRefs } from './paint-certification-6rwQjIv_.js';
+import { A as AsciiRenderOptions, ba as renderMermaidASCII$1, ag as RenderedAscii, bb as renderMermaidSVG$1, bc as RenderedSvg } from './index-EeXqJXr5.js';
+export { c as AsciiRenderColorMode, d as AsciiWidthError, e as AsciiWidthErrorReason, B as BACKEND_CONFORMANCE_CHECK_IDS, f as BACKEND_CONFORMANCE_FIXTURE_ID, g as BACKEND_CONFORMANCE_VERSION, h as BackendCapabilityConformanceResult, i as BackendCapabilityConformanceStatus, j as BackendConformanceCheck, k as BackendConformanceCheckId, l as BackendConformanceReport, m as BackendDescriptor, n as BackendRegistrationOptions, D as DefaultBackend, E as EXTERNAL_SCENE_API_VERSION, o as ExternalSceneConnector, p as ExternalSceneConnectorGeometry, q as ExternalSceneConnectorLabel, r as ExternalSceneContainer, s as ExternalSceneDataMark, t as ExternalSceneDocument, u as ExternalSceneGeometry, v as ExternalSceneInput, w as ExternalSceneMarker, x as ExternalSceneNode, y as ExternalSceneNodeBase, z as ExternalSceneShape, C as ExternalSceneText, F as FamilyDetectionDiagnostic, G as HOSTED_FONT_RESOURCES, H as HostBackendPolicy, M as MAX_HOSTED_PNG_BYTES, I as MAX_HOSTED_PNG_PIXELS, J as MAX_PNG_FONT_DIRECTORIES, K as MAX_PNG_FONT_DIRECTORY_LENGTH, L as MAX_PNG_PIXELS, N as MAX_PNG_RASTER_DIMENSION, O as MermaidFamilyClassification, Q as MermaidFamilyDetectionError, R as NATIVE_PNG_HOST_ONLY_OPTION_FIELDS, S as NATIVE_PNG_OUTPUT_POLICY_FIELDS, T as NativePngHostOnlyOptionField, U as NativePngOutputPolicyField, V as PNG_DEFAULT_FONT_FAMILY, W as PNG_DEFAULT_MIN_LABEL_PX, X as PNG_DEFAULT_SCALE, Y as PNG_FONT_SOURCES, Z as PNG_NAPI_RUNTIME, _ as PNG_OUTPUT_OPTION_FIELDS, $ as PNG_OUTPUT_OPTION_FIELD_DESCRIPTORS, a0 as PNG_OUTPUT_POLICY_VERSION, a1 as PNG_WASM_RUNTIME, a2 as PORTABLE_PNG_OUTPUT_OPTION_FIELDS, a3 as PngFitTo, a4 as PngFontSource, a5 as PngOutputOptionField, a6 as PngOutputOptionFieldDescriptor, a7 as PngOutputOptionInputKind, a8 as PngOutputOptionPolicyState, a9 as PngOutputOptionReceiptState, aa as PngOutputOptionScope, a as PngOutputPolicyInput, ab as PngRasterDimensions, b as PngRuntimeProvenance, ac as PortablePngOutputOptionField, ad as PortablePngOutputOptions, ae as RESOURCE_MANIFEST, af as RESOURCE_MANIFEST_VERSION, ah as ResolvedPngOutputPolicy, ai as ResolvedTerminalOutputPolicy, aj as SCENE_CONTRACT_VERSION, ak as SCENE_VALIDATION_LIMITS, al as SCENE_VALIDATION_VERSION, am as SceneValidationDiagnostic, an as SceneValidationDiagnosticCode, ao as SceneValidationError, ap as SceneValidationOptions, aq as SceneValidationResult, ar as StyleBackend, as as StyleBackendContext, at as TERMINAL_BOUNDED_PADDING_X, au as TERMINAL_DEFAULT_BOX_BORDER_PADDING, av as TERMINAL_DEFAULT_PADDING_X, aw as TERMINAL_DEFAULT_PADDING_Y, ax as TERMINAL_OUTPUT_POLICY_VERSION, ay as TEXT_MEASUREMENT_CONTRACT, az as TerminalOutputPolicyError, aA as TerminalOutputPolicyInput, aB as TextMeasurementContract, aC as TextMeasurementInput, aD as TextMeasurementResult, aE as UPSTREAM_MERMAID_FAMILY_INDEX, aF as UpstreamFamilyDescriptor, aG as UpstreamHeaderDescriptor, aH as UpstreamHeaderMatch, aI as UpstreamMermaidFamilyIndex, aJ as assertHostedPngRasterBudget, aK as assertPngRasterBudget, aL as assertValidSceneDoc, aM as buildExternalScene, aN as classifyMermaidFamilyFromFirstLine, aO as findUpstreamFamilyByHeader, aP as getBackend, aQ as hostedFontResource, aR as knownBackendDescriptors, aS as measureText, aT as measureTextWidth, aU as normalizePortablePngBackground, aV as omitPngOutputOptions, aW as parseRegisteredMermaid, aX as pngNapiRuntimeProvenance, aY as pngOutputOptionsJsonSchema, aZ as pngRasterDimensions, a_ as prepareSvgForPngRasterization, a$ as projectNativePngOutputPolicyInput, b0 as projectPortablePngOutputOptions, b1 as registerBackend, b2 as resolvePngOutputPolicy, b3 as resolvePortablePngOutputPolicy, b4 as resolveTerminalOutputPolicy, b5 as runBackendConformance, b6 as svgIntrinsicDimensions, b7 as validateResourceManifest, b8 as validateSceneDoc, b9 as verifyResourceBytes } from './index-EeXqJXr5.js';
+import { m as Direction, d as LayoutRouteCertificate, L as LabelContent, n as PositionedDiagram, M as MermaidEdge, R as RenderOptions } from './types-BcS52Mjt.js';
+export { A as AnyPort, a as ArchitectureVisualOverrides, D as DiamondFacet, b as DisplayRun, E as EdgeRouteCertificate, F as FamilyEdgeRouteCertificate, c as FamilyRouteCertificate, e as LayoutRouteClass, P as PortSemanticRole, f as PortSide, g as PreparedDisplayText, h as RegionContainmentCertificate, i as RouteBlocker, j as RouteCertificate, k as RouteClass, l as RoutePortAssignment } from './types-BcS52Mjt.js';
+export { B as BINDABLE_ROLE_STYLE_PROPERTIES, a as BINDABLE_SCENE_ROLES, b as BRAND_CONSTRAINT_DESCRIPTORS, c as BRAND_CONSTRAINT_KINDS, d as BUILTIN_SCENE_ROLE_TRAITS, e as BindableSceneRole, f as BrandConstraint, g as BrandConstraintAction, h as BrandConstraintKind, E as EXACT_ROLE_STYLE_CONTRACT, i as EXACT_STYLE_SCENE_ROLES, j as ExactStyleSceneRole, k as ExtensionIdentity, R as ROLE_STYLE_PROPERTY_DESCRIPTORS, l as RoleStyleFor, m as RoleStyleSpec, n as RoleStyles, o as SCENE_ROLE_DESCRIPTORS, p as SEMANTIC_BINDING_CHANNELS, q as STYLE_COLOR_TOKEN_DESCRIPTORS, r as STYLE_SPEC_FIELD_DESCRIPTORS, s as STYLE_SPEC_FORMAT_VERSION, t as SceneRole, u as SemanticBinding, v as SemanticBindingChannel, w as SemanticSlots, x as StyleColors, y as StyleDescriptor, S as StyleInput, z as StyleReferenceResolution, A as StyleRegistrationOptions, C as StyleSpec, D as createExtensionIdentity, F as getStyle, G as inferBackend, H as knownStyleDescriptors, I as knownStyles, J as registerStyle, K as resolveSceneRoleTraits, L as resolveStyleReference, M as resolveStyleStack, N as sceneRoleTraits, O as styleSpecJsonSchema, P as validateStyleSpec } from './svg-styles-BdnoM7AT.js';
 
-type MermaidFact = string;
-interface CheckMermaidObjectSpec {
-    /** Required facts. Aliases: expected / require / required. */
-    include?: readonly string[];
-    expected?: readonly string[];
-    require?: readonly string[];
-    required?: readonly string[];
-    /** Forbidden facts. Aliases: absent / forbid / forbidden / unexpected. */
-    exclude?: readonly string[];
-    absent?: readonly string[];
-    forbid?: readonly string[];
-    forbidden?: readonly string[];
-    unexpected?: readonly string[];
-    /** When true, every emitted fact must be listed in the required set. */
-    exact?: boolean;
+interface TerminalIdentity {
+    id: string;
+    kind: Exclude<RenderedRegionKind, 'canvas'> | 'subgraph';
 }
-type CheckMermaidSpec = readonly string[] | CheckMermaidObjectSpec;
-interface CheckMermaidResult {
-    ok: boolean;
-    /** Required facts not present in the diagram. */
-    missing: string[];
-    /** Forbidden facts that were present, or extra facts under exact:true. */
-    unexpected: string[];
-    /** Full deterministic fact set used for the comparison. */
-    facts: string[];
+interface TerminalOwner {
+    id: string;
+    kind?: TerminalIdentity['kind'];
+    sourceLine?: number;
+    parent?: Readonly<TerminalIdentity>;
+    /** Semantic attachment only; grants no containment or geometry privileges. */
+    annotationTarget?: Readonly<TerminalIdentity>;
+    members?: readonly string[];
+    /** Shared runs may join only when their family layout declares a bundle. */
+    bundle?: string;
+    from?: string;
+    to?: string;
+    /** Producer promises a complete visible directional connector between its ports. */
+    route?: 'connected';
+}
+type TerminalSide = 'T' | 'R' | 'B' | 'L';
+interface TerminalMarker {
+    shape: 'arrow' | 'triangle' | 'open-arrow' | 'circle' | 'cross' | 'diamond' | 'wide-circle' | 'lollipop' | 'filled-diamond' | 'hollow-diamond' | 'sequence-cross' | 'half-top' | 'half-bottom' | 'stick-top' | 'stick-bottom' | 'cardinality-one' | 'cardinality-many';
+    direction?: TerminalSide;
+    ascii?: boolean;
+}
+interface TerminalCellSpan {
+    row: number;
+    start: number;
+    end: number;
+}
+interface TerminalPort {
+    nodeId: string;
+    x: number;
+    y: number;
+    side?: TerminalSide;
+    end: 'start' | 'end';
+    /** Authored item identity stays in nodeId when a container is the physical contact. */
+    boundary?: Readonly<TerminalIdentity>;
+    /** Model-owned expectation, declared separately from painting. Empty means
+     * deliberately unmarked; multiple cells retain ER cardinality semantics. */
+    markers?: readonly Readonly<TerminalMarker>[];
+    markerOffset?: number;
+    /** A declared family loss, backed by a diagnostic and owned fallback text. */
+    markerProjection?: string;
+    /** Sequence contacts a participant lifeline, not its header-card frame. */
+    surface?: 'frame' | 'lifeline';
+}
+interface TerminalRegion {
+    id: string;
+    kind: NonNullable<TerminalOwner['kind']>;
+    sourceLine?: number;
+    parentId?: string;
+    parentKind?: TerminalIdentity['kind'];
+    annotationTarget?: Readonly<TerminalIdentity>;
+    members?: readonly string[];
+    from?: string;
+    to?: string;
+    bundle?: string;
+    ports?: TerminalPort[];
+    canvasRow: number;
+    canvasColStart: number;
+    canvasColEnd: number;
+    rowSpan?: number;
+    projectedText?: string;
+    authoredTextCells?: Array<{
+        row: number;
+        column: number;
+        glyph: string;
+    }>;
+    ownedCellSpans: TerminalCellSpan[];
+    /** Relationship coverage hidden behind opaque marks; not visible ink. */
+    occludedCellSpans?: TerminalCellSpan[];
 }
-/** Facts for a parsed diagram. Output is sorted, de-duplicated, and single-line. */
-declare function describeMermaidFacts(d: ParsedDiagram): string[];
-/** Parse then emit facts. Parse failures are explicit Result errors. */
-declare function describeMermaidFactsSource(source: string): Result<string[], ParseError[]>;
-/** Check required/forbidden semantic facts against a parsed diagram. */
-declare function checkMermaid(d: ParsedDiagram, spec: CheckMermaidSpec): CheckMermaidResult;
-declare function checkMermaidSource(source: string, spec: CheckMermaidSpec): Result<CheckMermaidResult, ParseError[]>;
 
-interface SerializeOptions {
-    /**
-     * Wrapper emission policy. 'verbatim' (default) re-emits the leading source
-     * wrapper (frontmatter, init directives, comments) byte-identically from
-     * `meta.wrapperSource`, then re-emits any init directive authored *after*
-     * the family header that the serialized body does not already own — a
-     * structured serializer receives directive-free grammar, so without this the
-     * config would be lost. Such a directive therefore moves ahead of the
-     * header; source-preserving bodies keep theirs in place and are unaffected.
-     * 'canonical' synthesizes Mermaid's documented shape
-     * instead: one frontmatter block with `title`/`displayMode` at the top
-     * level and everything else nested under `config:`, init directives folded
-     * in (re-emitted raw only when their payload could not be folded), and
-     * wrapper comments dropped. Diagrams without a captured wrapper (e.g.
-     * synthesized from JSON payloads) always use canonical synthesis.
-     */
-    wrapper?: 'verbatim' | 'canonical';
+type RegionKind = Exclude<RenderedRegionKind, 'canvas'> | 'subgraph';
+type AsciiWarningCode = 'ASCII_RENDER_FAILED' | 'ASCII_EDGE_REGION_UNMAPPED' | TerminalProjectionDiagnosticCode;
+interface AsciiWarning {
+    code: AsciiWarningCode;
+    message: string;
+    severity: 'degraded';
+    cell?: TerminalProjectionDiagnostic['cell'];
 }
-declare function serializeMermaid(d: ParsedDiagram, opts?: SerializeOptions): string;
-declare function synthesizeFromGraph(payload: ValidDiagramPayload & {
-    kind: ValidDiagram['kind'];
-    body: Exclude<ValidDiagramPayload['body'], ExtensionDiagramBody>;
-}): Result<ValidDiagram, ParseError[]>;
-declare function synthesizeFromGraph(payload: ValidDiagramPayload): Result<ParsedDiagram, ParseError[]>;
+interface AsciiRegion extends Omit<TerminalRegion, 'ownedCellSpans'> {
+    /** Exact occupied geometry, including spaces, continuations and repeated occurrences. */
+    ownedCellSpans?: TerminalCellSpan[];
+}
+declare const ASCII_ROUTE_PARITY_CONTRACT: {
+    readonly version: 1;
+    readonly routeIntent: "shared-route-classes";
+    readonly svgSource: "route-contract classifyRoutes() + certificates";
+    readonly asciiSource: "family terminal geometry with owned cells, route classes, markers and intentional bundles";
+    readonly degradationWarnings: readonly ["ASCII_RENDER_FAILED", "ASCII_EDGE_REGION_UNMAPPED", "TERMINAL_OWNERSHIP_UNAVAILABLE"];
+};
+interface AsciiWithMeta {
+    ascii: string;
+    regions: AsciiRegion[];
+    actions: DiagramActionRecord[];
+    warnings: AsciiWarning[];
+    routeParity: typeof ASCII_ROUTE_PARITY_CONTRACT;
+}
+/** Metadata is emitted by the same execution as the text. No label search or rerender. */
+declare function renderMermaidASCIIWithMeta(input: ParsedDiagram | string, options?: AsciiRenderOptions): AsciiWithMeta;
+
+/**
+ * Reverse an ASCII flowchart render back to (best-effort) Mermaid source.
+ * Returns synthesized ids (N0, N1, …) with recovered labels and edges.
+ */
+declare function asciiToMermaid(ascii: string, opts?: {
+    direction?: 'TD' | 'LR';
+}): Result<string, ParseError[]>;
+
+declare function analyzeMermaid(d: ParsedDiagram): DiagramAnalysis;
+declare function analyzeMermaidSource(source: string): Result<DiagramAnalysis, ParseError[]>;
+declare function collectActionRecords(d: ParsedDiagram): DiagramActionRecord[];
 
 interface CreateMermaidOptions {
+    /** Legacy C4 dialect for a new diagram (default C4Context). */
+    c4Variant?: C4Variant;
     /** Layout direction for flowchart/state diagrams (default TD). Ignored elsewhere. */
     direction?: Direction;
 }
@@ -83,6 +146,16 @@ declare function createMermaid(kind: 'gantt', opts?: CreateMermaidOptions): Gant
 declare function createMermaid(kind: 'mindmap', opts?: CreateMermaidOptions): MindmapValidDiagram;
 declare function createMermaid(kind: 'gitgraph', opts?: CreateMermaidOptions): GitGraphValidDiagram;
 declare function createMermaid(kind: 'radar', opts?: CreateMermaidOptions): RadarValidDiagram;
+declare function createMermaid(kind: 'c4', opts?: CreateMermaidOptions): C4ValidDiagram;
+declare function createMermaid(kind: 'sankey', opts?: CreateMermaidOptions): SankeyValidDiagram;
+declare function createMermaid(kind: 'packet', opts?: CreateMermaidOptions): PacketValidDiagram;
+declare function createMermaid(kind: 'kanban', opts?: CreateMermaidOptions): KanbanValidDiagram;
+declare function createMermaid(kind: 'requirement', opts?: CreateMermaidOptions): RequirementValidDiagram;
+declare function createMermaid(kind: 'treemap', opts?: CreateMermaidOptions): TreemapValidDiagram;
+declare function createMermaid(kind: 'zenuml', opts?: CreateMermaidOptions): ZenUMLValidDiagram;
+declare function createMermaid(kind: 'eventmodeling', opts?: CreateMermaidOptions): EventModelingValidDiagram;
+declare function createMermaid(kind: 'ishikawa', opts?: CreateMermaidOptions): IshikawaValidDiagram;
+declare function createMermaid(kind: 'block', opts?: CreateMermaidOptions): BlockValidDiagram;
 declare function createMermaid(kind: DiagramKind, opts?: CreateMermaidOptions): MutableValidDiagram;
 declare function buildMermaid(kind: 'flowchart', ops: FlowchartMutationOp[], opts?: CreateMermaidOptions): Result<FlowchartValidDiagram, BuildError>;
 declare function buildMermaid(kind: 'state', ops: StateMutationOp[], opts?: CreateMermaidOptions): Result<StateValidDiagram, BuildError>;
@@ -99,52 +172,29 @@ declare function buildMermaid(kind: 'gantt', ops: GanttMutationOp[], opts?: Crea
 declare function buildMermaid(kind: 'mindmap', ops: MindmapMutationOp[], opts?: CreateMermaidOptions): Result<MindmapValidDiagram, BuildError>;
 declare function buildMermaid(kind: 'gitgraph', ops: GitGraphMutationOp[], opts?: CreateMermaidOptions): Result<GitGraphValidDiagram, BuildError>;
 declare function buildMermaid(kind: 'radar', ops: RadarMutationOp[], opts?: CreateMermaidOptions): Result<RadarValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'c4', ops: C4MutationOp[], opts?: CreateMermaidOptions): Result<C4ValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'sankey', ops: SankeyMutationOp[], opts?: CreateMermaidOptions): Result<SankeyValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'packet', ops: PacketMutationOp[], opts?: CreateMermaidOptions): Result<PacketValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'kanban', ops: KanbanMutationOp[], opts?: CreateMermaidOptions): Result<KanbanValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'requirement', ops: RequirementMutationOp[], opts?: CreateMermaidOptions): Result<RequirementValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'treemap', ops: TreemapMutationOp[], opts?: CreateMermaidOptions): Result<TreemapValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'zenuml', ops: ZenUMLMutationOp[], opts?: CreateMermaidOptions): Result<ZenUMLValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'eventmodeling', ops: EventModelingMutationOp[], opts?: CreateMermaidOptions): Result<EventModelingValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'ishikawa', ops: IshikawaMutationOp[], opts?: CreateMermaidOptions): Result<IshikawaValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'block', ops: BlockMutationOp[], opts?: CreateMermaidOptions): Result<BlockValidDiagram, BuildError>;
 declare function buildMermaid(kind: DiagramKind, ops: AnyMutationOp[], opts?: CreateMermaidOptions): Result<MutableValidDiagram, BuildError>;
 
-declare function edgeIdOf(edge: MermaidEdge, idx?: number): string;
-
-declare function mutate(d: FlowchartValidDiagram, op: FlowchartMutationOp): Result<FlowchartValidDiagram, MutationError>;
-declare function mutate(d: StateValidDiagram, op: StateMutationOp): Result<StateValidDiagram, MutationError>;
-declare function mutate(d: SequenceValidDiagram, op: SequenceMutationOp): Result<SequenceValidDiagram, MutationError>;
-declare function mutate(d: TimelineValidDiagram, op: TimelineMutationOp): Result<TimelineValidDiagram, MutationError>;
-declare function mutate(d: ClassValidDiagram, op: ClassMutationOp): Result<ClassValidDiagram, MutationError>;
-declare function mutate(d: ErValidDiagram, op: ErMutationOp): Result<ErValidDiagram, MutationError>;
-declare function mutate(d: JourneyValidDiagram, op: JourneyMutationOp): Result<JourneyValidDiagram, MutationError>;
-declare function mutate(d: ArchitectureValidDiagram, op: ArchitectureMutationOp): Result<ArchitectureValidDiagram, MutationError>;
-declare function mutate(d: XyChartValidDiagram, op: XyChartMutationOp): Result<XyChartValidDiagram, MutationError>;
-declare function mutate(d: PieValidDiagram, op: PieMutationOp): Result<PieValidDiagram, MutationError>;
-declare function mutate(d: QuadrantValidDiagram, op: QuadrantMutationOp): Result<QuadrantValidDiagram, MutationError>;
-declare function mutate(d: GanttValidDiagram, op: GanttMutationOp): Result<GanttValidDiagram, MutationError>;
-declare function mutate(d: RadarValidDiagram, op: RadarMutationOp): Result<RadarValidDiagram, MutationError>;
-declare function mutate(d: MutableValidDiagram, op: AnyMutationOp): Result<MutableValidDiagram, MutationError>;
-declare function mutate(d: ParsedDiagram, op: AnyMutationOp): Result<ParsedDiagram, MutationError>;
-/**
- * mutate with a shape check in front — the one choke point every UNTYPED edit
- * path funnels through: the declarative applyOps/buildChecked entrypoints, the
- * Code Mode facade, and the CLI `--op`/`--ops` path. Typed callers keep using
- * `mutate` directly, where the compiler already guarantees op shape;
- * `mutateChecked` restores that guarantee at the boundaries where ops arrive as
- * raw JSON.
- *
- * `validateOp` proves the op's SHAPE (field names, primitive types, enums)
- * BEFORE the mutator runs, so a malformed op is rejected with a prescriptive
- * INVALID_OP error instead of silently mangling the diagram. Semantics — does
- * the referenced node exist, is the id a duplicate — stay in the mutator, which
- * runs second on a shape-proven op. Result shape is identical to `mutate`, so
- * this is a drop-in wherever the raw mutator was called with untyped ops.
- */
-declare function mutateChecked(d: MutableValidDiagram, op: unknown): Result<MutableValidDiagram, MutationError>;
-declare function mutateChecked(d: ParsedDiagram, op: unknown): Result<ParsedDiagram, MutationError>;
-
 declare const MUTATION_OPS_BY_FAMILY: {
+    readonly zenuml: readonly ["upsert_participant", "remove_participant", "rename_participant", "insert_statement", "remove_statement", "set_statement", "set_title", "set_accessibility_title", "set_accessibility_description"];
+    readonly eventmodeling: readonly ["insert_frame", "remove_frame", "move_frame", "set_frame", "set_entities", "set_notes", "set_specifications", "set_data", "set_title", "set_accessibility_title", "set_accessibility_description"];
     readonly flowchart: readonly ["add_node", "remove_node", "rename_node", "set_label", "add_edge", "remove_edge", "set_shape", "set_direction", "add_subgraph", "remove_subgraph", "move_node", "define_class", "set_node_class", "set_node_style"];
-    readonly state: readonly ["add_state", "remove_state", "rename_state", "set_state_label", "add_transition", "remove_transition", "set_transition_label", "make_composite", "set_direction", "move_state", "dissolve_composite", "add_note", "remove_note", "set_note_text", "define_class", "set_state_class", "set_state_style", "set_transition_style"];
-    readonly sequence: readonly ["add_participant", "remove_participant", "add_message", "remove_message", "set_message_text", "move_message", "set_participant_label", "add_fragment", "remove_fragment", "set_fragment_label", "add_fragment_branch", "set_fragment_branch_label", "add_fragment_message", "remove_fragment_message", "set_fragment_message_text"];
+    readonly state: readonly ["add_state", "remove_state", "rename_state", "set_state_label", "add_transition", "remove_transition", "set_transition_label", "make_composite", "set_direction", "move_state", "dissolve_composite", "add_note", "remove_note", "set_note_text", "add_floating_note", "remove_floating_note", "set_floating_note_text", "define_class", "set_state_class", "set_state_style", "set_transition_style"];
+    readonly sequence: readonly ["add_participant", "remove_participant", "add_message", "remove_message", "set_message_text", "set_message_wrap", "move_message", "set_participant_label", "add_fragment", "remove_fragment", "set_fragment_label", "add_fragment_branch", "set_fragment_branch_label", "add_fragment_message", "remove_fragment_message", "set_fragment_message_text", "set_fragment_message_wrap"];
     readonly timeline: readonly ["set_title", "add_section", "remove_section", "set_section_label", "add_period", "remove_period", "set_period_label", "add_event", "remove_event", "set_event_text", "move_period", "move_event", "move_section", "set_accessibility_title", "set_accessibility_description"];
-    readonly class: readonly ["set_title", "add_class", "remove_class", "rename_class", "set_class_generic", "add_member", "remove_member", "add_relation", "remove_relation", "add_note", "remove_note", "set_class_namespace", "define_class", "set_css_class", "set_class_style"];
+    readonly class: readonly ["set_title", "add_class", "remove_class", "rename_class", "set_class_generic", "add_member", "remove_member", "add_interface", "add_relation", "remove_relation", "add_note", "remove_note", "set_class_namespace", "define_class", "set_css_class", "set_class_style"];
     readonly er: readonly ["add_entity", "remove_entity", "rename_entity", "set_entity_label", "add_attribute", "remove_attribute", "add_relation", "remove_relation", "set_direction", "define_class", "set_entity_class", "set_entity_style"];
     readonly journey: readonly ["set_title", "add_section", "remove_section", "set_section_label", "add_task", "remove_task", "set_task_text", "set_task_score", "set_task_actors", "rename_actor", "move_task", "move_section", "set_accessibility_title", "set_accessibility_description"];
-    readonly architecture: readonly ["set_title", "set_accessibility_title", "set_accessibility_description", "add_service", "remove_service", "rename_service", "set_service_label", "set_service_icon", "move_service", "add_junction", "remove_junction", "rename_junction", "move_junction", "add_group", "set_group_label", "remove_group", "add_edge", "update_edge", "remove_edge"];
+    readonly architecture: readonly ["set_title", "set_accessibility_title", "set_accessibility_description", "add_service", "remove_service", "rename_service", "set_service_label", "set_service_icon", "set_service_icon_text", "move_service", "add_junction", "remove_junction", "rename_junction", "move_junction", "add_group", "set_group_label", "remove_group", "add_edge", "update_edge", "remove_edge"];
     readonly xychart: readonly ["set_title", "set_x_axis", "set_y_axis", "add_series", "remove_series", "set_series_values", "set_series_name", "reorder_series", "set_orientation", "set_data_point"];
     readonly pie: readonly ["set_title", "set_show_data", "add_slice", "remove_slice", "rename_slice", "set_slice_value", "reorder_slice"];
     readonly quadrant: readonly ["set_title", "set_axis_labels", "set_quadrant_label", "add_point", "remove_point", "move_point", "rename_point"];
@@ -152,7 +202,16 @@ declare const MUTATION_OPS_BY_FAMILY: {
     readonly mindmap: readonly ["add_node", "remove_node", "rename_node", "set_label", "move_node", "set_shape", "set_icon", "set_node_class", "set_accessibility_title", "set_accessibility_description"];
     readonly gitgraph: readonly ["append_commit", "create_branch", "checkout_branch", "merge_branch", "cherry_pick", "set_commit_message", "set_commit_type", "set_commit_tags", "rename_branch", "set_accessibility_title", "set_accessibility_description"];
     readonly radar: readonly ["set_title", "add_axis", "remove_axis", "rename_axis", "set_axis_label", "reorder_axis", "add_curve", "remove_curve", "set_curve_values", "set_curve_value", "set_curve_label", "rename_curve", "reorder_curve", "set_config"];
+    readonly sankey: readonly ["add_link", "remove_link", "set_link_value", "rename_node"];
+    readonly c4: readonly ["add_element", "update_element", "rename_element", "reparent_element", "remove_element", "add_boundary", "update_boundary", "rename_boundary", "reparent_boundary", "remove_boundary", "add_relationship", "update_relationship", "remove_relationship", "set_title", "set_variant", "add_directive", "update_directive", "remove_directive"];
+    readonly packet: readonly ["set_title", "set_accessibility_title", "set_accessibility_description", "add_field", "remove_field", "set_field_label", "set_field_bits", "move_field"];
+    readonly kanban: readonly ["add_column", "remove_column", "set_column_label", "move_column", "add_task", "remove_task", "set_task_label", "set_task_metadata", "move_task", "set_icon", "set_class", "set_accessibility_title", "set_accessibility_description"];
+    readonly requirement: readonly ["set_direction", "add_requirement", "update_requirement", "add_element", "update_element", "rename_node", "remove_node", "add_relation", "remove_relation", "define_class", "set_node_class", "set_node_style"];
+    readonly treemap: readonly ["set_title", "add_node", "remove_node", "set_label", "set_value", "move_node", "define_class", "set_node_class", "set_accessibility_title", "set_accessibility_description"];
+    readonly ishikawa: readonly ["set_effect", "add_cause", "remove_cause", "set_label", "move_cause", "set_accessibility_title", "set_accessibility_description"];
+    readonly block: readonly ["set_columns", "add_block", "update_block", "rename_block", "remove_block", "move_block", "add_edge", "remove_edge", "define_class", "set_node_class", "set_node_style"];
 };
+
 type MutableFamilyId = keyof typeof MUTATION_OPS_BY_FAMILY;
 
 type OpFamily = MutableFamilyId;
@@ -210,6 +269,7 @@ declare function opSignatures(family: OpFamily): string[];
 interface VerifySummary {
     ok: boolean;
     warnings: VerifyResult['warnings'];
+    checks?: VerifyResult['checks'];
 }
 /** A mutation failure annotated with which op in the list failed. */
 type CheckedBuildError = MutationError & {
@@ -224,8 +284,9 @@ type CheckedBuildError = MutationError & {
 type OpEnvelope = {
     ok: true;
     family: DiagramKind;
-    /** canonical Mermaid source of the mutated diagram */
+    /** Canonical source by default; exact edited bytes in source-preserving mode. */
     source: string;
+    mode?: 'source-preserving';
     verify: VerifySummary;
 } | {
     ok: false;
@@ -252,6 +313,8 @@ interface ApplyOpsInput {
     source?: string;
     family?: string;
     ops: unknown;
+    /** Explicitly retain unsupported syntax while applying a bounded family edit. */
+    mode?: 'structured' | 'source-preserving';
 }
 /**
  * Plain-JSON-in / plain-JSON-out batch edit. Fail-fast, all-or-nothing: ops
@@ -261,13 +324,301 @@ interface ApplyOpsInput {
  */
 declare function applyOps(input: ApplyOpsInput): OpEnvelope;
 
-declare function verifyMermaid(input: ParsedDiagram | string, opts?: VerifyOptions): VerifyResult;
+type LayoutCertificateProof = 'edge-route' | 'region-containment';
+declare function layoutCertificateProof(cert: LayoutRouteCertificate): LayoutCertificateProof;
+
+type SequenceActorType = 'participant' | 'actor' | 'boundary' | 'control' | 'entity' | 'database' | 'collections' | 'queue';
+type SequenceMessageHead = 'none' | 'filled' | 'open' | 'cross' | 'half-top' | 'half-bottom' | 'stick-top' | 'stick-bottom';
+interface Actor {
+    /** An incoming endpoint outside the authored participants; no header/lifeline. */
+    external?: true;
+    wrap?: boolean;
+    id: string;
+    label: string;
+    labelContent?: LabelContent;
+    /** Closed official participant-glyph vocabulary. */
+    type: SequenceActorType;
+    /** Safe actor-menu links; callbacks and unsafe schemes are rejected. */
+    links?: Record<string, string>;
+    /** Index into `SequenceDiagram.boxes` of the box that frames this actor:
+     *  the one open when a statement first met it inside a box (upstream's
+     *  `actor.box`). */
+    box?: number;
+    /** Index of the message this actor is created at (`create participant …`);
+     *  its header box + lifeline start there instead of the diagram top. */
+    createMessageIndex?: number;
+    /** Index of the message this actor is destroyed at (`destroy …`); the
+     *  lifeline ends there with an X cross. */
+    destroyMessageIndex?: number;
+}
+interface Message {
+    /** Identity and lexical fragment supplied by another native sequence language. */
+    id?: string;
+    parentId?: string;
+    /** Effective soft-wrap control; absent retains the renderer's default. */
+    wrap?: boolean;
+    from: string;
+    to: string;
+    label: string;
+    labelContent?: LabelContent;
+    /** Arrow style: solid line or dashed line */
+    lineStyle: 'solid' | 'dashed';
+    /** Exact source and target endpoint semantics. */
+    startHead: SequenceMessageHead;
+    endHead: SequenceMessageHead;
+    centralStart: boolean;
+    centralEnd: boolean;
+    /** Activate the target lifeline (+) */
+    activate?: boolean;
+    /** Deactivate the source lifeline (-) */
+    deactivate?: boolean;
+    /** Sequence number assigned by `autonumber` (absent when numbering is off).
+     *  Display surfaces prefix it to the label ("1. label"). */
+    number?: number;
+}
+interface Note {
+    id?: string;
+    parentId?: string;
+    wrap?: boolean;
+    /** Which actor(s) the note is attached to */
+    actorIds: string[];
+    /** Note text content */
+    text: string;
+    textContent?: LabelContent;
+    /** Position relative to the actor(s) */
+    position: 'left' | 'right' | 'over';
+    /** Message index after which this note appears */
+    afterIndex: number;
+}
+
+interface ZenUMLSemanticScope {
+    fragmentId: string;
+    fragmentIndex: number;
+    type: ZenUMLFragmentType;
+    branchIndex: number;
+    branchKind: ZenUMLBranch['kind'];
+    condition?: string;
+}
+interface ZenUMLMessageContext {
+    message: Message;
+    kind: 'call' | 'async' | 'reply' | 'creation';
+    sourceId: string;
+    callAncestors: readonly string[];
+    scopes: readonly ZenUMLSemanticScope[];
+}
+interface ZenUMLNoteContext {
+    note: Note;
+    sourceId: string;
+    callAncestors: readonly string[];
+    scopes: readonly ZenUMLSemanticScope[];
+}
+
+/** Every describe format, for the CLI flag, the MCP tool schema, and argument checks. */
+declare const DESCRIBE_FORMATS: readonly ["text", "json", "facts"];
+type DescribeFormat = (typeof DESCRIBE_FORMATS)[number];
+interface DescribeOptions {
+    /** 'text' (default): prose summary. 'json': structured AX tree (#7349). 'facts': deterministic semantic facts. */
+    format?: DescribeFormat;
+}
+/** Structured accessibility tree (#7349): the graph as a list of nodes + edges. */
+interface DescribeTree {
+    kind: string;
+    /** Visible document title, when retained by this family's readback. */
+    title?: string;
+    nodes: Array<{
+        id: string;
+        label: string;
+        parentId?: string;
+        value?: number;
+        /** Renderer-owned endpoint, not an authored participant. */
+        external?: true;
+        zenuml?: {
+            kind: 'participant';
+            type: Actor['type'];
+        } | (Pick<ZenUMLNoteContext, 'sourceId' | 'callAncestors' | 'scopes'> & {
+            kind: 'note';
+            actorIds: readonly string[];
+            position: ZenUMLNoteContext['note']['position'];
+            afterIndex: number;
+        });
+        c4?: ({
+            category: 'element';
+            effectiveShape: C4Shape;
+        } & Pick<C4Element, 'kind' | 'external' | 'shape' | 'parentId'>) | ({
+            category: 'boundary';
+        } & Pick<C4Boundary, 'kind' | 'parentId'>);
+    }>;
+    edges: Array<{
+        from: string;
+        to: string;
+        label?: string;
+        sequence?: {
+            fragmentIndex: number;
+            branchIndex: number;
+            fragmentKind: string;
+            branchLabel?: string;
+        };
+        zenuml?: Pick<ZenUMLMessageContext, 'kind' | 'sourceId' | 'callAncestors' | 'scopes'> & {
+            id: string;
+        };
+        c4?: Pick<C4Relationship, 'id' | 'order' | 'index' | 'macro' | 'direction' | 'bidirectional' | 'reversed'> & {
+            authoredFrom: string;
+            authoredTo: string;
+        };
+    }>;
+    entryPoints: string[];
+    sinks: string[];
+}
+declare function describeMermaidSource(source: string, opts?: DescribeOptions): string;
+declare function describeMermaid(d: ParsedDiagram, opts?: DescribeOptions): string;
+/**
+ * #7349: machine-readable accessibility tree — the graph as a flat node/edge
+ * list with entry points and sinks. More useful to agents and screen-reader
+ * tooling than prose. Covers the structured families; source-level/opaque
+ * families expose extracted labels as nodes and no edges.
+ */
+declare function describeMermaidTree(d: ParsedDiagram): DescribeTree;
+
+type MermaidFact = string;
+interface CheckMermaidObjectSpec {
+    /** Required facts. Aliases: expected / require / required. */
+    include?: readonly string[];
+    expected?: readonly string[];
+    require?: readonly string[];
+    required?: readonly string[];
+    /** Forbidden facts. Aliases: absent / forbid / forbidden / unexpected. */
+    exclude?: readonly string[];
+    absent?: readonly string[];
+    forbid?: readonly string[];
+    forbidden?: readonly string[];
+    unexpected?: readonly string[];
+    /** When true, every emitted fact must be listed in the required set. */
+    exact?: boolean;
+}
+type CheckMermaidSpec = readonly string[] | CheckMermaidObjectSpec;
+interface CheckMermaidResult {
+    ok: boolean;
+    /** Required facts not present in the diagram. */
+    missing: string[];
+    /** Forbidden facts that were present, or extra facts under exact:true. */
+    unexpected: string[];
+    /** Full deterministic fact set used for the comparison. */
+    facts: string[];
+}
+/** Facts for a parsed diagram. Output is sorted, de-duplicated, and single-line. */
+declare function describeMermaidFacts(d: ParsedDiagram): string[];
+/** Parse then emit facts. Parse failures are explicit Result errors. */
+declare function describeMermaidFactsSource(source: string): Result<string[], ParseError[]>;
+/** Check required/forbidden semantic facts against a parsed diagram. */
+declare function checkMermaid(d: ParsedDiagram, spec: CheckMermaidSpec): CheckMermaidResult;
+declare function checkMermaidSource(source: string, spec: CheckMermaidSpec): Result<CheckMermaidResult, ParseError[]>;
+
+/**
+ * Invoke a descriptor's pure positioned view without parsing or laying out.
+ * This open-id form is useful to extension conformance tests even though the
+ * current public `RenderedLayout` envelope remains a closed built-in union.
+ */
+declare function projectPositionedView(familyId: FamilyId, positioned: PositionedDiagram, options?: FamilyPositionedProjectionOptions): FamilyPositionedView | null;
+
+/** Register a namespaced extension only after its canonical example proves
+ * every native declaration twice against the public execution contracts. */
+declare function registerFamily(descriptor: FamilyDescriptor): () => void;
+
+declare function edgeIdOf(edge: MermaidEdge, idx?: number): string;
+
+declare function mutate(d: FlowchartValidDiagram, op: FlowchartMutationOp): Result<FlowchartValidDiagram, MutationError>;
+declare function mutate(d: StateValidDiagram, op: StateMutationOp): Result<StateValidDiagram, MutationError>;
+declare function mutate(d: SequenceValidDiagram, op: SequenceMutationOp): Result<SequenceValidDiagram, MutationError>;
+declare function mutate(d: TimelineValidDiagram, op: TimelineMutationOp): Result<TimelineValidDiagram, MutationError>;
+declare function mutate(d: ClassValidDiagram, op: ClassMutationOp): Result<ClassValidDiagram, MutationError>;
+declare function mutate(d: ErValidDiagram, op: ErMutationOp): Result<ErValidDiagram, MutationError>;
+declare function mutate(d: JourneyValidDiagram, op: JourneyMutationOp): Result<JourneyValidDiagram, MutationError>;
+declare function mutate(d: ArchitectureValidDiagram, op: ArchitectureMutationOp): Result<ArchitectureValidDiagram, MutationError>;
+declare function mutate(d: XyChartValidDiagram, op: XyChartMutationOp): Result<XyChartValidDiagram, MutationError>;
+declare function mutate(d: PieValidDiagram, op: PieMutationOp): Result<PieValidDiagram, MutationError>;
+declare function mutate(d: QuadrantValidDiagram, op: QuadrantMutationOp): Result<QuadrantValidDiagram, MutationError>;
+declare function mutate(d: GanttValidDiagram, op: GanttMutationOp): Result<GanttValidDiagram, MutationError>;
+declare function mutate(d: RadarValidDiagram, op: RadarMutationOp): Result<RadarValidDiagram, MutationError>;
+declare function mutate(d: C4ValidDiagram, op: C4MutationOp): Result<C4ValidDiagram, MutationError>;
+declare function mutate(d: SankeyValidDiagram, op: SankeyMutationOp): Result<SankeyValidDiagram, MutationError>;
+declare function mutate(d: PacketValidDiagram, op: PacketMutationOp): Result<PacketValidDiagram, MutationError>;
+declare function mutate(d: KanbanValidDiagram, op: KanbanMutationOp): Result<KanbanValidDiagram, MutationError>;
+declare function mutate(d: RequirementValidDiagram, op: RequirementMutationOp): Result<RequirementValidDiagram, MutationError>;
+declare function mutate(d: TreemapValidDiagram, op: TreemapMutationOp): Result<TreemapValidDiagram, MutationError>;
+declare function mutate(d: EventModelingValidDiagram, op: EventModelingMutationOp): Result<EventModelingValidDiagram, MutationError>;
+declare function mutate(d: IshikawaValidDiagram, op: IshikawaMutationOp): Result<IshikawaValidDiagram, MutationError>;
+declare function mutate(d: BlockValidDiagram, op: BlockMutationOp): Result<BlockValidDiagram, MutationError>;
+declare function mutate(d: MutableValidDiagram, op: AnyMutationOp): Result<MutableValidDiagram, MutationError>;
+declare function mutate(d: ParsedDiagram, op: AnyMutationOp): Result<ParsedDiagram, MutationError>;
+/**
+ * mutate with a shape check in front — the one choke point every UNTYPED edit
+ * path funnels through: the declarative applyOps/buildChecked entrypoints, the
+ * Code Mode facade, and the CLI `--op`/`--ops` path. Typed callers keep using
+ * `mutate` directly, where the compiler already guarantees op shape;
+ * `mutateChecked` restores that guarantee at the boundaries where ops arrive as
+ * raw JSON.
+ *
+ * `validateOp` proves the op's SHAPE (field names, primitive types, enums)
+ * BEFORE the mutator runs, so a malformed op is rejected with a prescriptive
+ * INVALID_OP error instead of silently mangling the diagram. Semantics — does
+ * the referenced node exist, is the id a duplicate — stay in the mutator, which
+ * runs second on a shape-proven op. Result shape is identical to `mutate`, so
+ * this is a drop-in wherever the raw mutator was called with untyped ops.
+ */
+declare function mutateChecked(d: MutableValidDiagram, op: unknown): Result<MutableValidDiagram, MutationError>;
+declare function mutateChecked(d: ParsedDiagram, op: unknown): Result<ParsedDiagram, MutationError>;
+interface SourceMutationResult {
+    /** Save these exact bytes. Unsupported syntax remains source-preserved;
+     * this artifact is not promised to be portable Mermaid. */
+    readonly source: string;
+    readonly diagram: ParsedDiagram;
+}
+/** Explicit source-level edits for opaque bodies. Family hooks admit only
+ * operations whose complete native read-back changes by the requested delta.
+ * Ordinary mutate, checked batches and canonical writers retain their contracts. */
+declare function mutatePreservingSource(d: ParsedDiagram, op: unknown): Result<SourceMutationResult, MutationError>;
+
+interface LabelConflictCounts {
+    total: number;
+    labelLabel: number;
+    labelNode: number;
+    labelEdge: number;
+}
 
 interface QualityMetrics {
+    /** Evidence from the actual native paint projection, when this layout retains it. */
+    paintCertification?: PaintLayoutCertification;
     edgeCrossings: number;
     labelLegibility: number;
+    labelMeasurement: {
+        measuredNodes: number;
+        unmeasuredNodes: number;
+        hiddenNodes: number;
+        semanticNodes: number;
+        measuredEdges: number;
+        unmeasuredEdges: number;
+        measuredLabels: number;
+        unmeasuredLabels: number;
+        hiddenLabels: number;
+        semanticLabels: number;
+    };
     whitespaceBalance: number;
     labelEdgeProximity: number;
+    /** Padded label-pill conflicts for graph families with retained pill geometry. */
+    labelConflicts?: LabelConflictCounts;
+    /** Visible graph edge pairs sharing collinear ink. These remain distinct
+     * from proper crossings; hiding a crossing in shared ink is not a win.
+     * Parallel excludes self-loops, matching the existing route rubric. */
+    routeOverlaps?: {
+        parallel: number;
+        opposing: number;
+    };
+    /** Raw visible polyline geometry, without subjective bundle/bend exemptions. */
+    routeGeometry?: {
+        bends: number;
+        length: number;
+        area: number;
+    };
     minimumNodeSpacing: number;
     elementDensity: number;
     minimumTextContrast: number | null;
@@ -276,7 +627,7 @@ interface QualityMetrics {
     edgeCount: number;
 }
 interface QualityBounds {
-    /** Max edge crossings per (edge × edge) pair. Default 0.05 = 5%. */
+    /** Max proper crossing incidences per visible edge pair. Default 0.05 = 5%. */
     maxCrossingsRatio?: number;
     /** Min label legibility. Default 0.85 = 85% of labels fit. */
     minLabelLegibility?: number;
@@ -315,7 +666,7 @@ interface BoundProvenance {
     note: string;
 }
 /** Per-metric provenance. Keyed by the QualityMetrics field each bound gates. */
-declare const BOUND_PROVENANCE: Record<'edgeCrossings' | 'labelLegibility' | 'whitespaceBalance' | 'labelEdgeProximity' | 'minimumNodeSpacing' | 'elementDensity' | 'minimumTextContrast' | 'aspectRatio', BoundProvenance>;
+declare const BOUND_PROVENANCE: Record<'paintCertification' | 'edgeCrossings' | 'labelLegibility' | 'whitespaceBalance' | 'labelEdgeProximity' | 'minimumNodeSpacing' | 'elementDensity' | 'minimumTextContrast' | 'aspectRatio', BoundProvenance>;
 declare function measureQuality(layout: RenderedLayout, options?: QualityMeasurementOptions): QualityMetrics;
 interface RankedViolation {
     metric: keyof typeof BOUND_PROVENANCE;
@@ -334,118 +685,35 @@ interface QualityVerdict {
 }
 declare function checkQuality(layout: RenderedLayout, bounds?: QualityBounds, measurement?: QualityMeasurementOptions): QualityVerdict;
 
-type LayoutCertificateProof = 'edge-route' | 'region-containment';
-declare function layoutCertificateProof(cert: LayoutRouteCertificate): LayoutCertificateProof;
-
-declare class FamilyConformanceError extends Error {
-    readonly report: FamilyConformanceReport;
-    constructor(report: FamilyConformanceReport);
-}
-/** Register a namespaced extension only after its canonical example proves
- * every native declaration twice against the public execution contracts. */
-declare function registerFamily(descriptor: FamilyDescriptor): () => void;
-
-/**
- * Invoke a descriptor's pure positioned view without parsing or laying out.
- * This open-id form is useful to extension conformance tests even though the
- * current public `RenderedLayout` envelope remains a closed built-in union.
- */
-declare function projectPositionedView(familyId: FamilyId, positioned: PositionedDiagram, options?: FamilyPositionedProjectionOptions): FamilyPositionedView | null;
-
-type RegionKind = Exclude<RenderedRegionKind, 'canvas' | 'group'> | 'group' | 'subgraph';
-type AsciiWarningCode = 'ASCII_RENDER_FAILED' | 'ASCII_EDGE_REGION_UNMAPPED' | TerminalProjectionDiagnosticCode;
-interface AsciiWarning {
-    code: AsciiWarningCode;
-    message: string;
-    severity: 'degraded';
-}
-declare const ASCII_ROUTE_PARITY_CONTRACT: {
-    readonly version: 1;
-    readonly routeIntent: "shared-route-classes";
-    readonly svgSource: "route-contract classifyRoutes() + certificates";
-    readonly asciiSource: "grid router seeded with classifyRoutes() routeClass metadata, longest-path layering, and direct-lane-first routing";
-    readonly degradationWarnings: readonly ["ASCII_RENDER_FAILED", "ASCII_EDGE_REGION_UNMAPPED"];
-};
-interface AsciiRegion {
-    kind: RegionKind;
-    /** Stable identifier for the diagram element (e.g. node id, participant id). */
-    id: string;
-    /** Optional 1-based source line where the element was declared, when known. */
-    sourceLine?: number;
-    /** 0-based row in the rendered canvas where the region starts. */
-    canvasRow: number;
-    /** 0-based column where the region starts (inclusive). */
-    canvasColStart: number;
-    /** 0-based column where the region ends (exclusive). */
-    canvasColEnd: number;
-    /** Optional row count when the region spans multiple lines (boxed node). */
-    rowSpan?: number;
-    /** Normalized text this best-effort label region was matched from. */
-    projectedText?: string;
-    /** Exact rendered cells claimed by authored label glyphs. Route detectors use
-     * this position-specific mask instead of exempting a glyph everywhere. */
-    authoredTextCells?: Array<{
-        row: number;
-        column: number;
-        glyph: string;
-    }>;
-}
-interface AsciiWithMeta {
-    ascii: string;
-    regions: AsciiRegion[];
-    /** Inert action records keyed to the same stable target ids as `regions`. */
-    actions: DiagramActionRecord[];
-    warnings: AsciiWarning[];
-    routeParity: typeof ASCII_ROUTE_PARITY_CONTRACT;
-}
-declare function renderMermaidASCIIWithMeta(input: ParsedDiagram | string, opts?: AsciiRenderOptions): AsciiWithMeta;
-
-interface DescribeOptions {
-    /** 'text' (default): prose summary. 'json': structured AX tree (#7349). 'facts': deterministic semantic facts. */
-    format?: 'text' | 'json' | 'facts';
-}
-/** Structured accessibility tree (#7349): the graph as a list of nodes + edges. */
-interface DescribeTree {
-    kind: string;
-    nodes: Array<{
-        id: string;
-        label: string;
-    }>;
-    edges: Array<{
-        from: string;
-        to: string;
-        label?: string;
-        sequence?: {
-            fragmentIndex: number;
-            branchIndex: number;
-            fragmentKind: string;
-            branchLabel?: string;
-        };
-    }>;
-    entryPoints: string[];
-    sinks: string[];
+interface SerializeOptions {
+    /**
+     * Wrapper emission policy. 'verbatim' (default) re-emits the leading source
+     * wrapper (frontmatter, init directives, comments) byte-identically from
+     * `meta.wrapperSource`, except adjacent frontmatter delimiters with no content
+     * line, which Mermaid rejects. It then re-emits any init directive authored *after*
+     * the family header that the serialized body does not already own — a
+     * structured serializer receives directive-free grammar, so without this the
+     * config would be lost. Such a directive therefore moves ahead of the
+     * header; source-preserving bodies keep theirs in place and are unaffected.
+     * 'canonical' synthesizes Mermaid's documented shape
+     * instead: one frontmatter block with `title`/`displayMode` at the top
+     * level and config values nested under `config:`. A single object init
+     * directive folds in; multiple init layers retain their order and boundaries.
+     * Invalid configuration must be repaired before canonical export, and
+     * wrapper comments dropped. Diagrams without a captured wrapper (e.g.
+     * synthesized from JSON payloads) always use canonical synthesis.
+     */
+    wrapper?: 'verbatim' | 'canonical';
 }
-declare function describeMermaidSource(source: string, opts?: DescribeOptions): string;
-declare function describeMermaid(d: ParsedDiagram, opts?: DescribeOptions): string;
-/**
- * #7349: machine-readable accessibility tree — the graph as a flat node/edge
- * list with entry points and sinks. More useful to agents and screen-reader
- * tooling than prose. Covers the structured families; source-level/opaque
- * families expose extracted labels as nodes and no edges.
- */
-declare function describeMermaidTree(d: ParsedDiagram): DescribeTree;
-
-declare function analyzeMermaid(d: ParsedDiagram): DiagramAnalysis;
-declare function analyzeMermaidSource(source: string): Result<DiagramAnalysis, ParseError[]>;
-declare function collectActionRecords(d: ParsedDiagram): DiagramActionRecord[];
+declare function serializeMermaid(d: ParsedDiagram, opts?: SerializeOptions): string;
+declare function synthesizeFromGraph(payload: ValidDiagramPayload & {
+    kind: ValidDiagram['kind'];
+    body: Exclude<ValidDiagramPayload['body'], ExtensionDiagramBody>;
+}): Result<ValidDiagram, ParseError[]>;
+declare function synthesizeFromGraph(payload: ValidDiagramPayload): Result<ParsedDiagram, ParseError[]>;
 
-/**
- * Reverse an ASCII flowchart render back to (best-effort) Mermaid source.
- * Returns synthesized ids (N0, N1, …) with recovered labels and edges.
- */
-declare function asciiToMermaid(ascii: string, opts?: {
-    direction?: 'TD' | 'LR';
-}): Result<string, ParseError[]>;
+/** The legacy ok flag is an error gate, never a task-correctness certificate. */
+declare function verifyMermaid(input: ParsedDiagram | string, opts?: VerifyOptions): VerifyResult;
 
 declare function renderMermaidSVG(input: ParsedDiagram | string, opts?: Parameters<typeof renderMermaidSVG$1>[1]): string;
 declare function renderMermaidSVGWithReceipt(input: ParsedDiagram | string, opts?: Parameters<typeof renderMermaidSVG$1>[1]): RenderedSvg;
@@ -465,4 +733,4 @@ interface RenderedLayoutArtifact {
 declare function layoutMermaidWithReceipt(input: ParsedDiagram | string, opts?: LayoutRenderOptions): RenderedLayoutArtifact;
 declare function layoutMermaid(d: ParsedDiagram, opts?: LayoutMermaidOptions): RenderedLayout;
 
-export { ASCII_ROUTE_PARITY_CONTRACT, AnyMutationOp, type ApplyOpsInput, ArchitectureMutationOp, ArchitectureValidDiagram, type AsciiRegion, AsciiRenderOptions, type AsciiWarning, type AsciiWarningCode, type AsciiWithMeta, BOUND_PROVENANCE, type BoundBasis, type BoundProvenance, type BuildError, type CheckMermaidObjectSpec, type CheckMermaidResult, type CheckMermaidSpec, type CheckedBuildError, ClassMutationOp, ClassValidDiagram, type CreateMermaidOptions, DEFAULT_BOUNDS, type DescribeOptions, type DescribeTree, DiagramActionRecord, DiagramAnalysis, DiagramKind, ErMutationOp, ErValidDiagram, ExtensionDiagramBody, FamilyConformanceError, FamilyConformanceReport, FamilyDescriptor, FamilyId, FamilyPositionedProjectionOptions, FamilyPositionedView, FlowchartMutationOp, FlowchartValidDiagram, GanttMutationOp, GanttValidDiagram, GitGraphMutationOp, GitGraphValidDiagram, JourneyMutationOp, JourneyValidDiagram, type LayoutCertificateProof, type LayoutMermaidOptions, type LayoutRenderOptions, LayoutRouteCertificate, type MermaidFact, MindmapMutationOp, MindmapValidDiagram, MutableValidDiagram, MutationError, type OpEnvelope, type OpFamily, type OpFieldDoc, type OpValidationError, ParseError, ParsedDiagram, PieMutationOp, PieValidDiagram, QuadrantMutationOp, QuadrantValidDiagram, type QualityBounds, type QualityMeasurementOptions, type QualityMetrics, type QualityVerdict, RadarMutationOp, RadarValidDiagram, type RankedViolation, type RegionKind, RenderRequestReceipt, RenderedAscii, RenderedLayout, type RenderedLayoutArtifact, RenderedRegionKind, Result, SequenceMutationOp, SequenceValidDiagram, StateMutationOp, StateValidDiagram, TimelineMutationOp, TimelineValidDiagram, ValidDiagram, ValidDiagramPayload, VerifyOptions, VerifyResult, type VerifySummary, type ViolationSeverity, XyChartMutationOp, XyChartValidDiagram, analyzeMermaid, analyzeMermaidSource, applyOps, asciiToMermaid, buildChecked, buildMermaid, checkMermaid, checkMermaidSource, checkQuality, collectActionRecords, createMermaid, describeMermaid, describeMermaidFacts, describeMermaidFactsSource, describeMermaidSource, describeMermaidTree, describeOps, edgeIdOf, hasOpSchema, layoutCertificateProof, layoutMermaid, layoutMermaidWithReceipt, measureQuality, mutate, mutateChecked, opMenu, opSignatures, projectPositionedView, registerFamily, renderMermaidASCII, renderMermaidASCIIWithMeta, renderMermaidASCIIWithReceipt, renderMermaidSVG, renderMermaidSVGWithReceipt, serializeMermaid, synthesizeFromGraph, validateOp, verifyMermaid, verifySummary };
+export { ASCII_ROUTE_PARITY_CONTRACT, AnyMutationOp, type ApplyOpsInput, ArchitectureMutationOp, ArchitectureValidDiagram, type AsciiRegion, AsciiRenderOptions, type AsciiWarning, type AsciiWarningCode, type AsciiWithMeta, BOUND_PROVENANCE, BlockMutationOp, BlockValidDiagram, type BoundBasis, type BoundProvenance, type BuildError, C4Boundary, C4Element, C4MutationOp, C4Relationship, C4Shape, C4ValidDiagram, C4Variant, type CheckMermaidObjectSpec, type CheckMermaidResult, type CheckMermaidSpec, type CheckedBuildError, ClassMutationOp, ClassValidDiagram, type CreateMermaidOptions, DEFAULT_BOUNDS, type DescribeOptions, type DescribeTree, DiagramActionRecord, DiagramAnalysis, DiagramKind, ErMutationOp, ErValidDiagram, EventModelingMutationOp, EventModelingValidDiagram, ExtensionDiagramBody, FamilyDescriptor, FamilyId, FamilyPositionedProjectionOptions, FamilyPositionedView, FlowchartMutationOp, FlowchartValidDiagram, GanttMutationOp, GanttValidDiagram, GitGraphMutationOp, GitGraphValidDiagram, IshikawaMutationOp, IshikawaValidDiagram, JourneyMutationOp, JourneyValidDiagram, KanbanMutationOp, KanbanValidDiagram, LabelContent, type LayoutCertificateProof, type LayoutMermaidOptions, type LayoutRenderOptions, LayoutRouteCertificate, type MermaidFact, MindmapMutationOp, MindmapValidDiagram, MutableValidDiagram, MutationError, type OpEnvelope, type OpFamily, type OpFieldDoc, type OpValidationError, PacketMutationOp, PacketValidDiagram, PaintLayoutCertification, ParseError, ParsedDiagram, PieMutationOp, PieValidDiagram, QuadrantMutationOp, QuadrantValidDiagram, type QualityBounds, type QualityMeasurementOptions, type QualityMetrics, type QualityVerdict, RadarMutationOp, RadarValidDiagram, type RankedViolation, type RegionKind, RenderRequestReceipt, RenderedAscii, RenderedLayout, type RenderedLayoutArtifact, RenderedRegionKind, RequirementMutationOp, RequirementValidDiagram, Result, SankeyMutationOp, SankeyValidDiagram, SequenceMutationOp, SequenceValidDiagram, type SourceMutationResult, StateMutationOp, StateValidDiagram, TimelineMutationOp, TimelineValidDiagram, TreemapMutationOp, TreemapValidDiagram, ValidDiagram, ValidDiagramPayload, VerifyOptions, VerifyResult, type VerifySummary, type ViolationSeverity, XyChartMutationOp, XyChartValidDiagram, ZenUMLBranch, ZenUMLMutationOp, ZenUMLValidDiagram, analyzeMermaid, analyzeMermaidSource, applyOps, asciiToMermaid, buildChecked, buildMermaid, checkMermaid, checkMermaidSource, checkQuality, collectActionRecords, createMermaid, describeMermaid, describeMermaidFacts, describeMermaidFactsSource, describeMermaidSource, describeMermaidTree, describeOps, edgeIdOf, hasOpSchema, layoutCertificateProof, layoutMermaid, layoutMermaidWithReceipt, measureQuality, mutate, mutateChecked, mutatePreservingSource, opMenu, opSignatures, projectPositionedView, registerFamily, renderMermaidASCII, renderMermaidASCIIWithMeta, renderMermaidASCIIWithReceipt, renderMermaidSVG, renderMermaidSVGWithReceipt, serializeMermaid, synthesizeFromGraph, validateOp, verifyMermaid, verifySummary };