agentic-mermaid 0.1.0 → 0.1.2

package/assets/fonts/FONT-LICENSES.md

@@ -2,11 +2,14 @@
 
 The `.ttf` files in this directory ship inside the `agentic-mermaid` npm
 package so PNG rasterization (`renderMermaidPNG`) is deterministic and
-offline: DejaVu Sans is the default face, and the four OFL faces are the
-typefaces referenced by the built-in styles (hand-drawn, excalidraw,
-watercolor → Caveat; pen-and-ink, tufte → EB Garamond; freehand →
-Architects Daughter; blueprint → Share Tech Mono). Custom styles that
-reference other families can supply them via the `fontDirs` PNG option.
+offline: Inter (weights 400/500/600/700 — the weights the SVG output
+requests) is the default face and the family the text-metrics model is
+calibrated for; DejaVu Sans serves as the per-glyph fallback for symbols
+Inter lacks; and the remaining OFL faces are the typefaces referenced by
+the built-in styles (hand-drawn, excalidraw, watercolor → Caveat;
+pen-and-ink, tufte → EB Garamond; freehand → Architects Daughter;
+blueprint → Share Tech Mono). Custom styles that reference other families
+can supply them via the `fontDirs` PNG option.
 
 ## OFL-1.1 faces
 
@@ -16,6 +19,7 @@ required by OFL condition 2.
 
 | File | Typeface | Copyright / Reserved Font Name | Source |
 |---|---|---|---|
+| `Inter-Regular.ttf`, `Inter-Medium.ttf`, `Inter-SemiBold.ttf`, `Inter-Bold.ttf` | Inter (v4.001 statics, weights 400/500/600/700) | Copyright 2016 The Inter Project Authors (https://github.com/rsms/inter) | fonts.google.com/specimen/Inter |
 | `Caveat.ttf` | Caveat | Copyright 2014 The Caveat Project Authors (https://github.com/googlefonts/caveat) | fonts.google.com/specimen/Caveat |
 | `EBGaramond.ttf` | EB Garamond | Copyright 2017 The EB Garamond Project Authors (https://github.com/octaviopardo/EBGaramond12) | fonts.google.com/specimen/EB+Garamond |
 | `ArchitectsDaughter.ttf` | Architects Daughter | Copyright (c) 2010, Kimberly Geswein (kimberlygeswein.com) | fonts.google.com/specimen/Architects+Daughter |

package/dist/agent-core.d.ts

@@ -0,0 +1,463 @@
+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-D54dqSdC.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-D54dqSdC.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;
+}
+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[]>;
+
+interface SerializeOptions {
+    /**
+     * Wrapper emission policy. 'verbatim' (default) re-emits the leading source
+     * wrapper (frontmatter, init directives, comments) byte-identically from
+     * `meta.wrapperSource`. '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';
+}
+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 CreateMermaidOptions {
+    /** Layout direction for flowchart/state diagrams (default TD). Ignored elsewhere. */
+    direction?: Direction;
+}
+/** A mutation failure annotated with which op in the build list failed. */
+type BuildError = MutationError & {
+    opIndex: number;
+};
+declare function createMermaid(kind: 'flowchart', opts?: CreateMermaidOptions): FlowchartValidDiagram;
+declare function createMermaid(kind: 'state', opts?: CreateMermaidOptions): StateValidDiagram;
+declare function createMermaid(kind: 'sequence', opts?: CreateMermaidOptions): SequenceValidDiagram;
+declare function createMermaid(kind: 'timeline', opts?: CreateMermaidOptions): TimelineValidDiagram;
+declare function createMermaid(kind: 'class', opts?: CreateMermaidOptions): ClassValidDiagram;
+declare function createMermaid(kind: 'er', opts?: CreateMermaidOptions): ErValidDiagram;
+declare function createMermaid(kind: 'journey', opts?: CreateMermaidOptions): JourneyValidDiagram;
+declare function createMermaid(kind: 'architecture', opts?: CreateMermaidOptions): ArchitectureValidDiagram;
+declare function createMermaid(kind: 'xychart', opts?: CreateMermaidOptions): XyChartValidDiagram;
+declare function createMermaid(kind: 'pie', opts?: CreateMermaidOptions): PieValidDiagram;
+declare function createMermaid(kind: 'quadrant', opts?: CreateMermaidOptions): QuadrantValidDiagram;
+declare function createMermaid(kind: 'gantt', opts?: CreateMermaidOptions): GanttValidDiagram;
+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: 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>;
+declare function buildMermaid(kind: 'sequence', ops: SequenceMutationOp[], opts?: CreateMermaidOptions): Result<SequenceValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'timeline', ops: TimelineMutationOp[], opts?: CreateMermaidOptions): Result<TimelineValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'class', ops: ClassMutationOp[], opts?: CreateMermaidOptions): Result<ClassValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'er', ops: ErMutationOp[], opts?: CreateMermaidOptions): Result<ErValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'journey', ops: JourneyMutationOp[], opts?: CreateMermaidOptions): Result<JourneyValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'architecture', ops: ArchitectureMutationOp[], opts?: CreateMermaidOptions): Result<ArchitectureValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'xychart', ops: XyChartMutationOp[], opts?: CreateMermaidOptions): Result<XyChartValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'pie', ops: PieMutationOp[], opts?: CreateMermaidOptions): Result<PieValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'quadrant', ops: QuadrantMutationOp[], opts?: CreateMermaidOptions): Result<QuadrantValidDiagram, BuildError>;
+declare function buildMermaid(kind: 'gantt', ops: GanttMutationOp[], opts?: CreateMermaidOptions): Result<GanttValidDiagram, BuildError>;
+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: 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 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 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 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 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"];
+    readonly gantt: readonly ["set_title", "add_section", "rename_section", "remove_section", "add_task", "remove_task", "rename_task", "set_task_status", "set_task_dates", "set_task_flags", "set_task_id", "move_task", "move_section"];
+    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"];
+};
+type MutableFamilyId = keyof typeof MUTATION_OPS_BY_FAMILY;
+
+type OpFamily = MutableFamilyId;
+/** True when `family` has a shape schema (i.e. is a mutable structured family).
+ *  Own-property only: `family in SCHEMAS` would report inherited Object.prototype
+ *  names (`toString`, `constructor`, `__proto__`, …) as families and mis-narrow them. */
+declare function hasOpSchema(family: string): family is OpFamily;
+/**
+ * Structured, model-actionable validation error. `code` is always INVALID_OP
+ * (so it flows through the existing MutationError channel unchanged), but the
+ * payload names the exact problem and enumerates the legal fields so a weak
+ * model can self-correct in one turn.
+ */
+interface OpValidationError {
+    code: 'INVALID_OP';
+    /** 'expected_single_op' | 'unknown_kind' | 'unknown_field' | 'missing_field' | 'wrong_type' | 'require_one_of' */
+    reason: string;
+    message: string;
+    family: OpFamily;
+    opKind?: string;
+    /** the offending field, when applicable */
+    field?: string;
+    /** valid field names for this op (or valid op kinds, for unknown_kind) */
+    validFields?: string[];
+    /** nearest valid name to a typo'd field/kind, when an obvious match exists */
+    didYouMean?: string;
+}
+declare function validateOp(family: OpFamily, op: unknown): OpValidationError | null;
+/** Machine-readable op menu for a family — { opKind: [fieldName, …] } — the
+ *  basis for tool-discovery output. Optional fields are marked with a trailing
+ *  `?`; the op's `kind` is implicit and omitted. */
+declare function opMenu(family: OpFamily): Record<string, string[]>;
+/** One field of an op, as a model needs it to fill the op correctly: the name,
+ *  whether it is required, and a human type that spells out enum values inline
+ *  (e.g. `one of "inheritance", "composition", …`). */
+interface OpFieldDoc {
+    name: string;
+    required: boolean;
+    type: string;
+    note?: string;
+}
+/** Full field shapes for every op of a family — the thing a model must know to
+ *  author a correct op without guessing (which the prescriptive INVALID_OP error
+ *  only teaches AFTER a wrong guess). Surfaced in `am capabilities --json` and
+ *  the declarative MCP tool descriptions so field names, required-ness, and enum
+ *  vocabularies are discoverable up front. */
+declare function describeOps(family: OpFamily): Record<string, OpFieldDoc[]>;
+/** Compact one-line signatures for a family's ops — `add_relation(from, to,
+ *  relKind, label?)` — for embedding in a tool description. Optional fields carry
+ *  a trailing `?`; enum values are left to `describeOps`/the error to keep the
+ *  menu short. */
+declare function opSignatures(family: OpFamily): string[];
+
+/** A verify summary reduced to plain JSON (no RenderedLayout proxy graph). */
+interface VerifySummary {
+    ok: boolean;
+    warnings: VerifyResult['warnings'];
+}
+/** A mutation failure annotated with which op in the list failed. */
+type CheckedBuildError = MutationError & {
+    opIndex: number;
+};
+/**
+ * THE single output DTO for the declarative surface. Success and failure share
+ * one shape: `ok` discriminates. Every field is plain JSON — safe to return
+ * straight out as an MCP tool result and safe to JSON round-trip: no
+ * `{ok,value}`-vs-plain split, no provenance proxy, no Map.
+ */
+type OpEnvelope = {
+    ok: true;
+    family: DiagramKind;
+    /** canonical Mermaid source of the mutated diagram */
+    source: string;
+    verify: VerifySummary;
+} | {
+    ok: false;
+    family: OpFamily | DiagramKind | null;
+    /** index of the failing op within the batch, when the failure is op-scoped */
+    opIndex?: number;
+    error: OpValidationError | {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+};
+/** Drop the layout proxy graph; keep the model-actionable verdict. The JSON
+ *  round-trip guarantees no residual Map / prototype leaks through. */
+declare function verifySummary(v: VerifyResult): VerifySummary;
+/**
+ * buildMermaid's contract (createMermaid → fold ops) with the shape check in
+ * front of every op. Same Result shape as buildMermaid, so it is a drop-in for
+ * the untyped build path (Code Mode facade `buildMermaid`, declarative `build`).
+ */
+declare function buildChecked(kind: DiagramKind, ops: unknown[], opts?: CreateMermaidOptions): Result<MutableValidDiagram, CheckedBuildError>;
+interface ApplyOpsInput {
+    /** Existing Mermaid `source` to edit, OR `family` to author from blank. */
+    source?: string;
+    family?: string;
+    ops: unknown;
+}
+/**
+ * Plain-JSON-in / plain-JSON-out batch edit. Fail-fast, all-or-nothing: ops
+ * apply in order over a working copy; the first invalid or semantically-rejected
+ * op stops the batch and reports its index — nothing is committed (the input
+ * `source` is untouched, mirroring buildMermaid). Returns the canonical envelope.
+ */
+declare function applyOps(input: ApplyOpsInput): OpEnvelope;
+
+declare function verifyMermaid(input: ParsedDiagram | string, opts?: VerifyOptions): VerifyResult;
+
+interface QualityMetrics {
+    edgeCrossings: number;
+    labelLegibility: number;
+    whitespaceBalance: number;
+    labelEdgeProximity: number;
+    minimumNodeSpacing: number;
+    elementDensity: number;
+    minimumTextContrast: number | null;
+    aspectRatio: number;
+    nodeCount: number;
+    edgeCount: number;
+}
+interface QualityBounds {
+    /** Max edge crossings per (edge × edge) pair. Default 0.05 = 5%. */
+    maxCrossingsRatio?: number;
+    /** Min label legibility. Default 0.85 = 85% of labels fit. */
+    minLabelLegibility?: number;
+    /** Whitespace fill band [min, max]. Default [0.05, 0.55]. */
+    whitespaceBand?: [number, number];
+    /** Min pixels between any edge-label bbox and a non-attached node, another edge-label, or another edge path. Default 4. */
+    minLabelEdgeProximity?: number;
+    /** Min pixels between distinct node/mark boxes. Default 8. */
+    minNodeSpacing?: number;
+    /** Elements (nodes + edges) per 10,000 canvas pixels. Default [0.02, 6]. */
+    elementDensityBand?: [number, number];
+    /** Minimum WCAG text contrast ratio. Default 4.5 (AA normal text). */
+    minTextContrast?: number;
+    /** Aspect ratio band [min, max]. Default [0.2, 5.0]. */
+    aspectBand?: [number, number];
+}
+declare const DEFAULT_BOUNDS: Required<QualityBounds>;
+interface QualityMeasurementOptions {
+    /** Text/foreground paint. Defaults to the crisp theme foreground. */
+    foreground?: string;
+    /** Canvas paint. Defaults to the crisp theme background. */
+    background?: string;
+    /** Additional node/label fills to include in the minimum contrast. */
+    surfaces?: readonly string[];
+    /** Exact rendered text/surface pairs; these supersede foreground/surfaces while background remains the canvas paint. */
+    textPairs?: readonly {
+        foreground: string;
+        background: string;
+    }[];
+}
+type BoundBasis = 'evidence' | 'standard' | 'derived' | 'chosen' | 'sanity';
+type ViolationSeverity = 'primary' | 'secondary' | 'sanity';
+interface BoundProvenance {
+    basis: BoundBasis;
+    severity: ViolationSeverity;
+    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 function measureQuality(layout: RenderedLayout, options?: QualityMeasurementOptions): QualityMetrics;
+interface RankedViolation {
+    metric: keyof typeof BOUND_PROVENANCE;
+    severity: ViolationSeverity;
+    message: string;
+}
+interface QualityVerdict {
+    ok: boolean;
+    metrics: QualityMetrics;
+    /**
+     * The same violations, each tagged with its evidence-based severity so a
+     * consumer can weight a crossings violation above a whitespace one
+     * (Purchase 1997/2002). Ordered primary → secondary → sanity.
+     */
+    ranked: RankedViolation[];
+}
+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[];
+}
+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[];
+
+/**
+ * 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 renderMermaidSVG(input: ParsedDiagram | string, opts?: Parameters<typeof renderMermaidSVG$1>[1]): string;
+declare function renderMermaidSVGWithReceipt(input: ParsedDiagram | string, opts?: Parameters<typeof renderMermaidSVG$1>[1]): RenderedSvg;
+declare function renderMermaidASCII(input: ParsedDiagram | string, opts?: Parameters<typeof renderMermaidASCII$1>[1]): string;
+declare function renderMermaidASCIIWithReceipt(input: ParsedDiagram | string, opts?: Parameters<typeof renderMermaidASCII$1>[1]): RenderedAscii;
+interface LayoutMermaidOptions extends RenderOptions {
+    debug?: boolean;
+    regions?: boolean;
+    actions?: boolean;
+}
+type LayoutRenderOptions = LayoutMermaidOptions;
+interface RenderedLayoutArtifact {
+    layout: RenderedLayout;
+    receipt: RenderRequestReceipt;
+}
+/** Canonical layout transport for Code Mode and other receipt-aware adapters. */
+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 };