@cohesivesystems/relations 0.1.0-alpha.4 → 0.1.0-alpha.6

package/src/generated/relations.shapes.generated.ts

@@ -1,35 +1,1055 @@
 /* <auto-generated/> */
 
-export interface GraphId {
-  Value: string;
+export type GraphId = string;
+
+export type ShapeId = string;
+
+export type RelationQueryExplainStage = {
+  readonly $stage: 'staticCompilation';
+} & RelationQueryStaticCompilationExplainStage | {
+  readonly $stage: 'profileFeasibility';
+} & RelationQueryProfileFeasibilityExplainStage | {
+  readonly $stage: 'sourcePlacement';
+} & RelationQuerySourcePlacementExplainStage | {
+  readonly $stage: 'boundRealization';
+} & RelationQueryBoundRealizationExplainStage | {
+  readonly $stage: 'physicalPlanning';
+} & RelationQueryPhysicalPlanningExplainStage | {
+  readonly $stage: 'nativeCompilation';
+} & RelationQueryNativeCompilationExplainStage | {
+  readonly $stage: 'evaluation';
+} & RelationQueryEvaluationExplainStage;
+
+export interface RelationQueryStaticCompilationExplainStage {
+  status: RelationQueryExplainStageStatus;
+  request: RelationQueryCompilationRequestReference;
+  plan?: RelationQueryStaticPlanExplanation | null;
+  diagnostics: DocumentValidationDiagnostic[];
 }
 
-export interface ShapeId {
-  Value: string;
+export interface RelationQueryProfileFeasibilityExplainStage {
+  status: RelationQueryExplainStageStatus;
+  report: RelationQueryRealizationReport;
 }
 
-export interface RelationId {
-  Value: string;
+export interface RelationQuerySourcePlacementExplainStage {
+  status: RelationQueryExplainStageStatus;
+  placement: RelationQuerySourcePlacement;
 }
 
-export interface RelationName {
-  Value: string;
+export interface RelationQueryBoundRealizationExplainStage {
+  report: RelationQueryBoundRealizationReport;
+  status: RelationQueryExplainStageStatus;
 }
 
-export interface RelationSource {
-  Alias: SourceAlias;
-  ShapeId: ShapeId;
-  Cardinality: SourceCardinality;
+export interface RelationQueryPhysicalPlanningExplainStage {
+  status: RelationQueryExplainStageStatus;
+  plan: RelationQueryCompiledPlanReference;
+  realization: RelationQueryRealizationFingerprint;
+  placement: RelationQuerySourcePlacementFingerprint;
+  policy?: RelationQueryPhysicalPlanningPolicy | null;
+  result: RelationQueryPhysicalPlanningResult;
 }
 
-export interface JoinDefinition {
-  Left: SourceAlias;
-  Right: SourceAlias;
-  Kind: JoinKind;
-  On: Expr;
+export interface RelationQueryNativeCompilationExplainStage {
+  status: RelationQueryExplainStageStatus;
+  attempt: RelationQueryNativeCompilationAttemptReference;
+  compilation: RelationQueryNativeCompilationExplanation;
 }
 
+export interface RelationQueryEvaluationExplainStage {
+  evaluation: RelationQueryEvaluationExplanation;
+  status: RelationQueryExplainStageStatus;
+}
+
+export interface RelationQueryCapabilitySummary {
+  target: RelationQueryTargetId;
+  targetProfile: RelationQueryTargetProfileId;
+  policy?: RelationQueryRealizationPolicyId | null;
+  profileFeasibility?: RelationQueryRealizationFingerprint | null;
+  boundRealization?: RelationQueryBoundRealizationFingerprint | null;
+  operatingBoundaries: RelationQueryOperatingBoundaryId[];
+  entries: RelationQueryCapabilitySummaryEntry[];
+}
+
+export interface RelationQueryExplainDiagnostic {
+  stage: string;
+  code: string;
+  severity: DiagnosticSeverity;
+  message: string;
+  location?: string | null;
+  branch?: RelationQueryNativeResultBranchId | null;
+  requirement?: RelationQueryRealizationRequirementId | null;
+  node?: QueryNodeId | null;
+  input?: RelationQueryInputId | null;
+  output?: RelationQueryOutputId | null;
+  placementBinding?: RelationQuerySourcePlacementBindingId | null;
+  physicalStage?: RelationQueryPhysicalStageId | null;
+  source?: RelationQuerySourceInstanceId | null;
+  capabilityEvidence?: RelationQueryTargetCapabilityEvidenceId | null;
+  operatingBoundary?: RelationQueryOperatingBoundaryId | null;
+  contextEvidence?: RelationQueryContextEvidenceId | null;
+  semanticSite?: string | null;
+  compositionRule?: RelationQueryCompositionRuleId | null;
+  override?: RelationQueryRealizationOverrideId | null;
+  field?: FieldPath | null;
+  bindingSetting?: string | null;
+  resolution?: string | null;
+  configurationOrigin?: EffectiveConfigurationOrigin | null;
+  configurationAuthority?: string | null;
+  adapterDecisionCode?: RelationQueryAdapterDecisionCode | null;
+}
+
+export interface RelationQueryExplainFingerprint {
+  algorithm: string;
+  canonicalization: string;
+  value: string;
+}
+
+export interface RelationQueryCompiledPlanReference {
+  compilerProfile: string;
+  definitionSchemaVersion: string;
+  definitionFingerprint: RelationQueryDefinitionFingerprint;
+  shapeSnapshotsFingerprint: RelationQueryPlanComponentFingerprint;
+  relationshipCatalogFingerprint?: RelationshipCatalogFingerprint | null;
+  demandFingerprint: RelationQueryPlanComponentFingerprint;
+  inputs: RelationQueryInputId[];
+}
+
+export interface RelationQueryRealizationFingerprint {
+  algorithm: string;
+  canonicalization: string;
+  value: string;
+}
+
+export interface RelationQueryPhysicalPlanningPolicy {
+  id: RelationQueryPhysicalPlanningPolicyId;
+  conventionSetVersion: string;
+  maximumBatchSize: string;
+  maximumBufferedRows: string;
+  maximumLocalRows: string;
+  maximumFanOut: string;
+  maximumReferenceKeysPerObservation: string;
+  maximumConcurrency: string;
+  loweringSelections: RelationQueryPhysicalLoweringSelection[];
+}
+
+export interface RelationQueryPhysicalStage {
+  id: RelationQueryPhysicalStageId;
+  kind: RelationQueryPhysicalStageKind;
+  dependencies: RelationQueryPhysicalStageId[];
+  placementBinding?: RelationQuerySourcePlacementBindingId | null;
+  semanticInputs: RelationQueryInputId[];
+  requestedFields: RelationQueryInputId[];
+  batchSize?: string | null;
+  provenance: RelationQueryPhysicalStageProvenance;
+}
+
+export type RelationQueryPhysicalStageId = string;
+
+export interface RelationQueryPhysicalPlanningDiagnostic {
+  code: string;
+  severity: DiagnosticSeverity;
+  message: string;
+  input?: RelationQueryInputId | null;
+  stage?: RelationQueryPhysicalStageId | null;
+  placementBinding?: RelationQuerySourcePlacementBindingId | null;
+  requirement?: RelationQueryRealizationRequirementId | null;
+}
+
+export interface RelationQueryPhysicalPlanFingerprint {
+  algorithm: string;
+  canonicalization: string;
+  value: string;
+}
+
+export interface RelationQuerySourceInstance {
+  id: RelationQuerySourceInstanceId;
+  executionDomain: RelationQueryExecutionDomainId;
+  targetProfile: RelationQueryTargetCapabilityProfile;
+  limits: RelationQuerySourcePlacementLimits;
+}
+
+export interface RelationQuerySourcePlacementBinding {
+  id: RelationQuerySourcePlacementBindingId;
+  input: RelationQueryInputId;
+  node: QueryNodeId;
+  binding: ValueBindingId;
+  shape: QualifiedShapeId;
+  source: RelationQuerySourceInstanceId;
+  kind: RelationQuerySourcePlacementBindingKind;
+  acquisition: RelationQuerySourceAcquisitionKind;
+  origin: RelationQuerySourcePlacementOrigin;
+  identity?: RelationQuerySourceIdentityBinding | null;
+  fields: RelationQuerySourceFieldBinding[];
+  relationshipKeys: RelationQueryRelationshipKeyBinding[];
+  partition?: RelationQueryPartitionBinding | null;
+}
+
+export interface EffectiveConfigurationDecision {
+  setting: string;
+  origin: EffectiveConfigurationOrigin;
+  authority: string;
+}
+
+export interface RelationQuerySourcePlacementFingerprint {
+  algorithm: string;
+  canonicalization: string;
+  value: string;
+}
+
+export type RelationQueryNativeResultBranchId = string;
+
+export interface RelationQueryContextualEvidenceProjection {
+  binding: RelationQueryAdapterBindingReference;
+  assessments: RelationQueryBoundRequirementAssessment[];
+}
+
+export interface RelationQueryRealizationDiagnostic {
+  code: string;
+  severity: DiagnosticSeverity;
+  message: string;
+  requirement?: RelationQueryRealizationRequirementId | null;
+  capabilityEvidence?: RelationQueryTargetCapabilityEvidenceId | null;
+  compositionRule?: RelationQueryCompositionRuleId | null;
+  operatingBoundary?: RelationQueryOperatingBoundaryId | null;
+  override?: RelationQueryRealizationOverrideId | null;
+  node?: QueryNodeId | null;
+  semanticSite?: string | null;
+  contextEvidence?: RelationQueryContextEvidenceId | null;
+  branch?: RelationQueryNativeResultBranchId | null;
+  input?: RelationQueryInputId | null;
+  field?: FieldPath | null;
+  placementBinding?: RelationQuerySourcePlacementBindingId | null;
+  bindingSetting?: string | null;
+  resolution?: string | null;
+  configurationOrigin?: EffectiveConfigurationOrigin | null;
+  configurationAuthority?: string | null;
+  adapterDecisionCode?: RelationQueryAdapterDecisionCode | null;
+}
+
+export type RelationQueryRealizationStatus = 'Realizable' | 'NotRealizable' | 'Invalid';
+
+export const relationQueryRealizationStatuses = {
+  realizable: 'Realizable',
+  notRealizable: 'NotRealizable',
+  invalid: 'Invalid',
+} as const satisfies Record<string, RelationQueryRealizationStatus>;
+
+export const relationQueryRealizationStatusLabels: Record<RelationQueryRealizationStatus, string> = {
+  Realizable: 'Realizable',
+  NotRealizable: 'NotRealizable',
+  Invalid: 'Invalid',
+};
+
+export interface RelationQueryBoundRealizationFingerprint {
+  algorithm: string;
+  canonicalization: string;
+  value: string;
+}
+
+export interface RelationQueryRealizationPolicy {
+  id: RelationQueryRealizationPolicyId;
+  conventionSetVersion: string;
+  preference: RelationQueryRealizationPreference;
+  constrainedRealizations: RelationQueryConstrainedRealizationPolicy;
+  compositionRules: RelationQueryCompositionRule[];
+  compositionRuleSelections: RelationQueryCompositionRuleSelection[];
+  overrides: RelationQueryRealizationOverride[];
+  diagnosticSeverityOverrides: RelationQueryRealizationDiagnosticSeverityOverride[];
+}
+
+export interface RelationQueryResultObservability {
+  occurrenceProvenance: RelationQueryOccurrenceProvenanceMode;
+}
+
+export interface RelationQueryRealizationRequirement {
+  id: RelationQueryRealizationRequirementId;
+  capability: RelationQueryCapability;
+  origin?: RelationQueryRealizationRequirementOrigin | null;
+  uses: RelationQueryRealizationRequirementUse[];
+  requiredGuarantees: RelationQueryGuaranteeCapabilityKind[];
+  staticFacts: RelationQueryRealizationStaticFact[];
+}
+
+export type RelationQueryRealizationDecision = {
+  readonly $decision: 'native';
+} & NativeRelationQueryRealizationDecision | {
+  readonly $decision: 'composed';
+} & ComposedRelationQueryRealizationDecision | {
+  readonly $decision: 'constrained';
+} & ConstrainedRelationQueryRealizationDecision | {
+  readonly $decision: 'override';
+} & OverrideRelationQueryRealizationDecision | {
+  readonly $decision: 'unavailable';
+} & UnavailableRelationQueryRealizationDecision;
+
+export interface NativeRelationQueryRealizationDecision {
+  capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+  preservedGuarantees: RelationQueryGuaranteeCapabilityKind[];
+  requirement: RelationQueryRealizationRequirementId;
+}
+
+export interface ComposedRelationQueryRealizationDecision {
+  compositionRules: RelationQueryCompositionRuleId[];
+  capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+  preservedGuarantees: RelationQueryGuaranteeCapabilityKind[];
+  requirement: RelationQueryRealizationRequirementId;
+}
+
+export interface ConstrainedRelationQueryRealizationDecision {
+  capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+  boundaryValidations: RelationQueryOperatingBoundaryValidation[];
+  compositionRules: RelationQueryCompositionRuleId[];
+  preservedGuarantees: RelationQueryGuaranteeCapabilityKind[];
+  requirement: RelationQueryRealizationRequirementId;
+}
+
+export interface OverrideRelationQueryRealizationDecision {
+  override: RelationQueryRealizationOverrideId;
+  capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+  boundaryValidations: RelationQueryOperatingBoundaryValidation[];
+  preservedGuarantees: RelationQueryGuaranteeCapabilityKind[];
+  requirement: RelationQueryRealizationRequirementId;
+}
+
+export interface UnavailableRelationQueryRealizationDecision {
+  requirement: RelationQueryRealizationRequirementId;
+  reason: RelationQueryUnavailableReason;
+  missingCapabilities: RelationQueryCapability[];
+}
+
+export type RelationQueryTargetId = string;
+
+export type RelationQueryTargetProfileId = string;
+
+export interface RelationQueryTargetCapabilityEvidence {
+  id: RelationQueryTargetCapabilityEvidenceId;
+  capability: RelationQueryCapability;
+  operatingBoundaries: RelationQueryOperatingBoundaryId[];
+  description?: string | null;
+}
+
+export interface RelationQueryOperatingBoundary {
+  id: RelationQueryOperatingBoundaryId;
+  kind: RelationQueryOperatingBoundaryKind | number;
+  limit?: string | null;
+  description?: string | null;
+}
+
+export interface RelationDraft {
+  id: RelationDraftId;
+  relationId: RelationId;
+  name: RelationName;
+  input: LogicalQueryDefinition;
+  rootBinding: ValueBindingId;
+  projection: RelationDraftProjection;
+  outputMode: RelationOutputMode;
+  outputKey?: Expr | null;
+  invariants: InvariantDefinition[];
+}
+
+export interface RelationDraftFingerprint {
+  algorithm: string;
+  canonicalization: string;
+  value: string;
+}
+
+export interface RelationDraftDocumentMetadata {
+  origin: DocumentOrigin;
+  name?: string | null;
+  description?: string | null;
+  sourceUri?: string | null;
+  producer?: string | null;
+  producerVersion?: string | null;
+  createdAtUtc?: string | null;
+  updatedAtUtc?: string | null;
+  annotations: Record<string, AnnotationValue>;
+  producerArtifacts: RelationDraftProducerArtifactReference[];
+  conventionDecisions: RelationDraftConventionDecision[];
+}
+
+export type RelationQueryDefinition = {
+  readonly $definition: 'relation';
+} & RelationDefinition | {
+  readonly $definition: 'query';
+} & QueryDefinition;
+
+export interface RelationDefinition {
+  id: RelationId;
+  name: RelationName;
+  rootBinding: ValueBindingId;
+  output: RelationOutputDefinition;
+  invariants: InvariantDefinition[];
+  body: LogicalQueryDefinition;
+}
+
+export interface QueryDefinition {
+  id: QueryId;
+  name: QueryName;
+  results: QueryResultDefinition[];
+  body: LogicalQueryDefinition;
+}
+
+export interface RelationQueryDefinitionFingerprint {
+  algorithm: string;
+  canonicalization: string;
+  value: string;
+}
+
+export interface RelationQueryDocumentMetadata {
+  origin: DocumentOrigin;
+  name?: string | null;
+  description?: string | null;
+  sourceUri?: string | null;
+  producer?: string | null;
+  producerVersion?: string | null;
+  createdAtUtc?: string | null;
+  updatedAtUtc?: string | null;
+  annotations: Record<string, AnnotationValue>;
+}
+
+export interface RelationshipCatalog {
+  relationships: RelationshipDefinition[];
+}
+
+export interface RelationshipCatalogFingerprint {
+  algorithm: string;
+  canonicalization: string;
+  value: string;
+}
+
+export interface RelationshipCatalogDocumentMetadata {
+  origin: DocumentOrigin;
+  name?: string | null;
+  description?: string | null;
+  sourceUri?: string | null;
+  producer?: string | null;
+  producerVersion?: string | null;
+  createdAtUtc?: string | null;
+  updatedAtUtc?: string | null;
+  annotations: Record<string, AnnotationValue>;
+}
+
+export type RelationQueryExplainStageStatus = 'Complete' | 'Unavailable' | 'Invalid' | 'Incomplete' | 'Failed';
+
+export const relationQueryExplainStageStatuses = {
+  complete: 'Complete',
+  unavailable: 'Unavailable',
+  invalid: 'Invalid',
+  incomplete: 'Incomplete',
+  failed: 'Failed',
+} as const satisfies Record<string, RelationQueryExplainStageStatus>;
+
+export const relationQueryExplainStageStatusLabels: Record<RelationQueryExplainStageStatus, string> = {
+  Complete: 'Complete',
+  Unavailable: 'Unavailable',
+  Invalid: 'Invalid',
+  Incomplete: 'Incomplete',
+  Failed: 'Failed',
+};
+
+export interface RelationQueryCompilationRequestReference {
+  compilerProfile: string;
+  definitionSchemaVersion: string;
+  definitionFingerprint: RelationQueryDefinitionFingerprint;
+  shapeSnapshotsFingerprint: RelationQueryPlanComponentFingerprint;
+  relationshipCatalogFingerprint?: RelationshipCatalogFingerprint | null;
+  demandFingerprint: RelationQueryPlanComponentFingerprint;
+}
+
+export interface RelationQueryStaticPlanExplanation {
+  reference: RelationQueryCompiledPlanReference;
+  logicalPlan: RelationQueryLogicalPlan;
+  requirementGraph: RelationQueryExplainRequirementGraph;
+  branches: RelationQueryNativeResultBranch[];
+  observability: RelationQueryResultObservability;
+  realizationRequirements: RelationQueryRealizationRequirement[];
+  realizationRequirementsFingerprint: RelationQueryPlanComponentFingerprint;
+}
+
+export interface DocumentValidationDiagnostic {
+  code: string;
+  severity: DiagnosticSeverity;
+  message: string;
+  location?: string | null;
+  schemaLocation?: string | null;
+  evidence?: DocumentDiagnosticEvidence | null;
+}
+
+export interface RelationQueryPhysicalPlanningResult {
+  status: RelationQueryPhysicalPlanningStatus;
+  plan?: CompiledRelationQueryPhysicalPlan | null;
+  diagnostics: RelationQueryPhysicalPlanningDiagnostic[];
+}
+
+export interface RelationQueryNativeCompilationAttemptReference {
+  plan: RelationQueryCompiledPlanReference;
+  profileFeasibility: RelationQueryRealizationFingerprint;
+  boundRealization: RelationQueryBoundRealizationFingerprint;
+  placement: RelationQuerySourcePlacementFingerprint;
+  adapterBinding: RelationQueryAdapterBindingReference;
+  branches: RelationQueryNativeResultBranchId[];
+}
+
+export interface RelationQueryNativeCompilationExplanation {
+  status: RelationQueryNativeCompilationStatus;
+  artifacts: RelationQueryNativeArtifactReference[];
+  diagnostics: RelationQueryNativeCompilationDiagnostic[];
+}
+
+export interface RelationQueryEvaluationExplanation {
+  evaluation: RelationQueryEvaluationFingerprint;
+  plan?: RelationQueryCompiledPlanReference | null;
+  status: RelationQueryExecutionStatus;
+  results: RelationQueryExplainResultSummary[];
+  requirementGaps: RelationQueryExplainRequirementGapSummary[];
+  diagnostics: RelationQueryExplainDiagnostic[];
+  observationFingerprint: RelationQueryEvaluationObservationFingerprint;
+}
+
+export type RelationQueryRealizationPolicyId = string;
+
+export type RelationQueryOperatingBoundaryId = string;
+
+export interface RelationQueryCapabilitySummaryEntry {
+  capability: RelationQueryCapability;
+  requirements: RelationQueryRealizationRequirementId[];
+  missingForRequirements: RelationQueryRealizationRequirementId[];
+  capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+  operatingBoundaries: RelationQueryOperatingBoundaryId[];
+  contextEvidence: RelationQueryContextEvidenceId[];
+}
+
+export type DiagnosticSeverity = 'Info' | 'Warning' | 'Error';
+
+export const diagnosticSeverities = {
+  info: 'Info',
+  warning: 'Warning',
+  error: 'Error',
+} as const satisfies Record<string, DiagnosticSeverity>;
+
+export const diagnosticSeverityLabels: Record<DiagnosticSeverity, string> = {
+  Info: 'Info',
+  Warning: 'Warning',
+  Error: 'Error',
+};
+
+export type RelationQueryRealizationRequirementId = string;
+
+export type QueryNodeId = string;
+
+export type RelationQueryInputId = string;
+
+export type RelationQueryOutputId = string;
+
+export type RelationQuerySourcePlacementBindingId = string;
+
+export type RelationQuerySourceInstanceId = string;
+
+export type RelationQueryTargetCapabilityEvidenceId = string;
+
+export type RelationQueryContextEvidenceId = string;
+
+export type RelationQueryCompositionRuleId = string;
+
+export type RelationQueryRealizationOverrideId = string;
+
+export interface FieldPath {
+  segments: FieldPathSegment[];
+}
+
+export type EffectiveConfigurationOrigin = 'Explicit' | 'ScopedProfile' | 'AdapterConvention' | 'FrameworkDefault';
+
+export const effectiveConfigurationOrigins = {
+  explicit: 'Explicit',
+  scopedProfile: 'ScopedProfile',
+  adapterConvention: 'AdapterConvention',
+  frameworkDefault: 'FrameworkDefault',
+} as const satisfies Record<string, EffectiveConfigurationOrigin>;
+
+export const effectiveConfigurationOriginLabels: Record<EffectiveConfigurationOrigin, string> = {
+  Explicit: 'Explicit',
+  ScopedProfile: 'ScopedProfile',
+  AdapterConvention: 'AdapterConvention',
+  FrameworkDefault: 'FrameworkDefault',
+};
+
+export type RelationQueryAdapterDecisionCode = string;
+
+export interface RelationQueryPlanComponentFingerprint {
+  algorithm: string;
+  canonicalization: string;
+  value: string;
+}
+
+export type RelationQueryPhysicalPlanningPolicyId = string;
+
+export interface RelationQueryPhysicalLoweringSelection {
+  compositionRule: RelationQueryCompositionRuleId;
+  physicalLowering: RelationQueryPhysicalLoweringRuleId;
+}
+
+export type RelationQueryPhysicalStageKind = 'SuppliedInput' | 'SourceRead' | 'ExactFieldProjection' | 'RelationshipKeyExtraction' | 'KeyDeduplication' | 'BatchedIdentityLookup' | 'BatchedPredicateLookup' | 'LocalCorrelation' | 'RuntimeEvidenceAssembly' | 'ReferenceInterpreterTerminal';
+
+export const relationQueryPhysicalStageKinds = {
+  suppliedInput: 'SuppliedInput',
+  sourceRead: 'SourceRead',
+  exactFieldProjection: 'ExactFieldProjection',
+  relationshipKeyExtraction: 'RelationshipKeyExtraction',
+  keyDeduplication: 'KeyDeduplication',
+  batchedIdentityLookup: 'BatchedIdentityLookup',
+  batchedPredicateLookup: 'BatchedPredicateLookup',
+  localCorrelation: 'LocalCorrelation',
+  runtimeEvidenceAssembly: 'RuntimeEvidenceAssembly',
+  referenceInterpreterTerminal: 'ReferenceInterpreterTerminal',
+} as const satisfies Record<string, RelationQueryPhysicalStageKind>;
+
+export const relationQueryPhysicalStageKindLabels: Record<RelationQueryPhysicalStageKind, string> = {
+  SuppliedInput: 'SuppliedInput',
+  SourceRead: 'SourceRead',
+  ExactFieldProjection: 'ExactFieldProjection',
+  RelationshipKeyExtraction: 'RelationshipKeyExtraction',
+  KeyDeduplication: 'KeyDeduplication',
+  BatchedIdentityLookup: 'BatchedIdentityLookup',
+  BatchedPredicateLookup: 'BatchedPredicateLookup',
+  LocalCorrelation: 'LocalCorrelation',
+  RuntimeEvidenceAssembly: 'RuntimeEvidenceAssembly',
+  ReferenceInterpreterTerminal: 'ReferenceInterpreterTerminal',
+};
+
+export interface RelationQueryPhysicalStageProvenance {
+  nodes: QueryNodeId[];
+  inputs: RelationQueryInputId[];
+  requirements: RelationQueryRealizationRequirementId[];
+  capabilityEvidence: RelationQueryPhysicalCapabilityEvidenceReference[];
+  compositionRules: RelationQueryCompositionRuleId[];
+  operatingBoundaries: RelationQueryOperatingBoundaryId[];
+  placementBindings: RelationQuerySourcePlacementBindingId[];
+  loweringRule?: RelationQueryPhysicalLoweringRuleId | null;
+  policyDecisions: RelationQueryPhysicalPlanningDecisionId[];
+}
+
+export type RelationQueryExecutionDomainId = string;
+
+export interface RelationQuerySourcePlacementLimits {
+  maximumBatchSize: string;
+  maximumBufferedRows: string;
+  maximumFanOut: string;
+  maximumConcurrency: string;
+}
+
+export type ValueBindingId = string;
+
+export type RelationQuerySourcePlacementBindingKind = 'SourceSet' | 'RelationshipTraversal';
+
+export const relationQuerySourcePlacementBindingKinds = {
+  sourceSet: 'SourceSet',
+  relationshipTraversal: 'RelationshipTraversal',
+} as const satisfies Record<string, RelationQuerySourcePlacementBindingKind>;
+
+export const relationQuerySourcePlacementBindingKindLabels: Record<RelationQuerySourcePlacementBindingKind, string> = {
+  SourceSet: 'SourceSet',
+  RelationshipTraversal: 'RelationshipTraversal',
+};
+
+export type RelationQuerySourceAcquisitionKind = 'Supplied' | 'BoundedEnumeration' | 'BoundedLookup';
+
+export const relationQuerySourceAcquisitionKinds = {
+  supplied: 'Supplied',
+  boundedEnumeration: 'BoundedEnumeration',
+  boundedLookup: 'BoundedLookup',
+} as const satisfies Record<string, RelationQuerySourceAcquisitionKind>;
+
+export const relationQuerySourceAcquisitionKindLabels: Record<RelationQuerySourceAcquisitionKind, string> = {
+  Supplied: 'Supplied',
+  BoundedEnumeration: 'BoundedEnumeration',
+  BoundedLookup: 'BoundedLookup',
+};
+
+export type RelationQuerySourcePlacementOrigin = 'Explicit' | 'Convention';
+
+export const relationQuerySourcePlacementOrigins = {
+  explicit: 'Explicit',
+  convention: 'Convention',
+} as const satisfies Record<string, RelationQuerySourcePlacementOrigin>;
+
+export const relationQuerySourcePlacementOriginLabels: Record<RelationQuerySourcePlacementOrigin, string> = {
+  Explicit: 'Explicit',
+  Convention: 'Convention',
+};
+
+export interface RelationQuerySourceIdentityBinding {
+  shape: QualifiedShapeId;
+  sourceSelector: string;
+  semanticPath?: FieldPath | null;
+}
+
+export interface RelationQuerySourceFieldBinding {
+  input: RelationQueryInputId;
+  semanticPath: FieldPath;
+  sourceSelector: string;
+}
+
+export interface RelationQueryRelationshipKeyBinding {
+  input: RelationQueryInputId;
+  semanticPath: FieldPath;
+  sourceSelector: string;
+}
+
+export interface RelationQueryPartitionBinding {
+  sourceSelector: string;
+}
+
+export interface RelationQueryAdapterBindingReference {
+  schemaVersion: string;
+  bindingId: string;
+  target: RelationQueryTargetId;
+  targetProfile: RelationQueryTargetProfileId;
+  fingerprint: RelationQueryAdapterBindingFingerprint;
+  compiledPlanFingerprint?: RelationQueryPlanComponentFingerprint | null;
+  placementFingerprint?: RelationQuerySourcePlacementFingerprint | null;
+  sources: RelationQuerySourceInstanceId[];
+  placementBindings: RelationQuerySourcePlacementBindingId[];
+  configurationDecisions: EffectiveConfigurationDecision[];
+}
+
+export interface RelationQueryBoundRequirementAssessment {
+  id: RelationQueryContextEvidenceId;
+  branch: RelationQueryNativeResultBranchId;
+  requirement: RelationQueryRealizationRequirementId;
+  status: RelationQueryBoundAssessmentStatus;
+  origin: EffectiveConfigurationOrigin;
+  authority: string;
+  capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+  operatingBoundaries: RelationQueryOperatingBoundaryId[];
+  preservedGuarantees: RelationQueryGuaranteeCapabilityKind[];
+  unavailableReason?: RelationQueryUnavailableReason | null;
+  node?: QueryNodeId | null;
+  input?: RelationQueryInputId | null;
+  field?: FieldPath | null;
+  placementBinding?: RelationQuerySourcePlacementBindingId | null;
+  configurationSetting?: string | null;
+  message: string;
+  resolution?: string | null;
+  adapterDecisionCode?: RelationQueryAdapterDecisionCode | null;
+  missingCapabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+  failedOperatingBoundary?: RelationQueryOperatingBoundaryId | null;
+  failedConfigurationSetting?: string | null;
+  blockedBy?: RelationQueryContextEvidenceId | null;
+}
+
+export type RelationQueryRealizationPreference = 'PreferNative' | 'PreferComposed';
+
+export const relationQueryRealizationPreferences = {
+  preferNative: 'PreferNative',
+  preferComposed: 'PreferComposed',
+} as const satisfies Record<string, RelationQueryRealizationPreference>;
+
+export const relationQueryRealizationPreferenceLabels: Record<RelationQueryRealizationPreference, string> = {
+  PreferNative: 'PreferNative',
+  PreferComposed: 'PreferComposed',
+};
+
+export type RelationQueryConstrainedRealizationPolicy = 'Reject' | 'AllowValidated';
+
+export const relationQueryConstrainedRealizationPolicies = {
+  reject: 'Reject',
+  allowValidated: 'AllowValidated',
+} as const satisfies Record<string, RelationQueryConstrainedRealizationPolicy>;
+
+export const relationQueryConstrainedRealizationPolicyLabels: Record<RelationQueryConstrainedRealizationPolicy, string> = {
+  Reject: 'Reject',
+  AllowValidated: 'AllowValidated',
+};
+
+export interface RelationQueryCompositionRule {
+  id: RelationQueryCompositionRuleId;
+  providedCapability: RelationQueryCapability;
+  requiredCapabilities: RelationQueryCapability[];
+  requiredOperatingBoundaries: RelationQueryOperatingBoundaryId[];
+  preservedGuarantees: RelationQueryGuaranteeCapabilityKind[];
+  description?: string | null;
+}
+
+export interface RelationQueryCompositionRuleSelection {
+  capability: RelationQueryCapability;
+  rule: RelationQueryCompositionRuleId;
+}
+
+export interface RelationQueryRealizationOverride {
+  id: RelationQueryRealizationOverrideId;
+  requirement: RelationQueryRealizationRequirementId;
+  expectedCapability: RelationQueryCapability;
+  capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+  operatingBoundaries: RelationQueryOperatingBoundaryId[];
+  preservedGuarantees: RelationQueryGuaranteeCapabilityKind[];
+  justification: string;
+}
+
+export interface RelationQueryRealizationDiagnosticSeverityOverride {
+  code: string;
+  severity: DiagnosticSeverity;
+}
+
+export type RelationQueryOccurrenceProvenanceMode = 'ExactContributors' | 'NotRequested';
+
+export const relationQueryOccurrenceProvenanceModes = {
+  exactContributors: 'ExactContributors',
+  notRequested: 'NotRequested',
+} as const satisfies Record<string, RelationQueryOccurrenceProvenanceMode>;
+
+export const relationQueryOccurrenceProvenanceModeLabels: Record<RelationQueryOccurrenceProvenanceMode, string> = {
+  ExactContributors: 'ExactContributors',
+  NotRequested: 'NotRequested',
+};
+
+export type RelationQueryCapability = {
+  readonly $capability: 'logical';
+} & LogicalRelationQueryCapability | {
+  readonly $capability: 'expression';
+} & ExpressionRelationQueryCapability | {
+  readonly $capability: 'temporal';
+} & TemporalRelationQueryCapability | {
+  readonly $capability: 'structural';
+} & StructuralRelationQueryCapability | {
+  readonly $capability: 'guarantee';
+} & GuaranteeRelationQueryCapability | {
+  readonly $capability: 'operatingBoundaryValidation';
+} & OperatingBoundaryValidationRelationQueryCapability | {
+  readonly $capability: 'primitive';
+} & PrimitiveRelationQueryCapability;
+
+export interface LogicalRelationQueryCapability {
+  kind: RelationQueryLogicalCapabilityKind | number;
+}
+
+export interface ExpressionRelationQueryCapability {
+  capability: ExprCapabilityId;
+  requirementKind: ExprCapabilityRequirementKind | number;
+}
+
+export interface TemporalRelationQueryCapability {
+  capability: RelationQueryTemporalExecutionCapability | number;
+}
+
+export interface StructuralRelationQueryCapability {
+  role: RelationQueryStructuralCapabilityRole | number;
+  pathKind: RelationQueryStructuralPathKind | number;
+}
+
+export interface GuaranteeRelationQueryCapability {
+  kind: RelationQueryGuaranteeCapabilityKind | number;
+}
+
+export interface OperatingBoundaryValidationRelationQueryCapability {
+  boundary: RelationQueryOperatingBoundaryId;
+}
+
+export interface PrimitiveRelationQueryCapability {
+  kind: RelationQueryPrimitiveCapabilityKind | number;
+}
+
+export interface RelationQueryRealizationRequirementOrigin {
+  input?: RelationQueryInputId | null;
+  node?: QueryNodeId | null;
+  semanticSite?: string | null;
+  expressionPath?: string | null;
+  fieldPath?: FieldPath | null;
+  binding?: ValueBindingId | null;
+}
+
+export interface RelationQueryRealizationRequirementUse {
+  output: RelationQueryRealizationOutputReference;
+  effect: RelationQueryRequirementEffect;
+  requirement: QueryInputRequirement;
+  traces: RelationQueryRealizationTrace[];
+}
+
+export type RelationQueryGuaranteeCapabilityKind = 'MissingNullDistinction' | 'AbsenceAvailabilityFailureDistinction' | 'JoinMembership' | 'Cardinality' | 'RelationshipDirection' | 'RelationshipMultiplicity' | 'TemporalDomain' | 'TemporalBoundary' | 'UnboundedTemporalBoundary' | 'Ordering' | 'NullPlacement' | 'StablePaging' | 'Grouping' | 'Aggregation' | 'DuplicateHandling' | 'OutputIdentity' | 'OutputMode' | 'InvariantEnforcement' | 'DeterministicResult' | 'OccurrenceProvenance' | 'EvidenceCompleteness' | 'InconclusiveEvidence' | 'ConsistentSnapshot' | 'CollectionElementCorrelation' | 'RelationRootCorrelation';
+
+export const relationQueryGuaranteeCapabilityKinds = {
+  missingNullDistinction: 'MissingNullDistinction',
+  absenceAvailabilityFailureDistinction: 'AbsenceAvailabilityFailureDistinction',
+  joinMembership: 'JoinMembership',
+  cardinality: 'Cardinality',
+  relationshipDirection: 'RelationshipDirection',
+  relationshipMultiplicity: 'RelationshipMultiplicity',
+  temporalDomain: 'TemporalDomain',
+  temporalBoundary: 'TemporalBoundary',
+  unboundedTemporalBoundary: 'UnboundedTemporalBoundary',
+  ordering: 'Ordering',
+  nullPlacement: 'NullPlacement',
+  stablePaging: 'StablePaging',
+  grouping: 'Grouping',
+  aggregation: 'Aggregation',
+  duplicateHandling: 'DuplicateHandling',
+  outputIdentity: 'OutputIdentity',
+  outputMode: 'OutputMode',
+  invariantEnforcement: 'InvariantEnforcement',
+  deterministicResult: 'DeterministicResult',
+  occurrenceProvenance: 'OccurrenceProvenance',
+  evidenceCompleteness: 'EvidenceCompleteness',
+  inconclusiveEvidence: 'InconclusiveEvidence',
+  consistentSnapshot: 'ConsistentSnapshot',
+  collectionElementCorrelation: 'CollectionElementCorrelation',
+  relationRootCorrelation: 'RelationRootCorrelation',
+} as const satisfies Record<string, RelationQueryGuaranteeCapabilityKind>;
+
+export const relationQueryGuaranteeCapabilityKindLabels: Record<RelationQueryGuaranteeCapabilityKind, string> = {
+  MissingNullDistinction: 'MissingNullDistinction',
+  AbsenceAvailabilityFailureDistinction: 'AbsenceAvailabilityFailureDistinction',
+  JoinMembership: 'JoinMembership',
+  Cardinality: 'Cardinality',
+  RelationshipDirection: 'RelationshipDirection',
+  RelationshipMultiplicity: 'RelationshipMultiplicity',
+  TemporalDomain: 'TemporalDomain',
+  TemporalBoundary: 'TemporalBoundary',
+  UnboundedTemporalBoundary: 'UnboundedTemporalBoundary',
+  Ordering: 'Ordering',
+  NullPlacement: 'NullPlacement',
+  StablePaging: 'StablePaging',
+  Grouping: 'Grouping',
+  Aggregation: 'Aggregation',
+  DuplicateHandling: 'DuplicateHandling',
+  OutputIdentity: 'OutputIdentity',
+  OutputMode: 'OutputMode',
+  InvariantEnforcement: 'InvariantEnforcement',
+  DeterministicResult: 'DeterministicResult',
+  OccurrenceProvenance: 'OccurrenceProvenance',
+  EvidenceCompleteness: 'EvidenceCompleteness',
+  InconclusiveEvidence: 'InconclusiveEvidence',
+  ConsistentSnapshot: 'ConsistentSnapshot',
+  CollectionElementCorrelation: 'CollectionElementCorrelation',
+  RelationRootCorrelation: 'RelationRootCorrelation',
+};
+
+export interface RelationQueryRealizationStaticFact {
+  kind: RelationQueryRealizationStaticFactKind;
+  value: string;
+}
+
+export interface RelationQueryOperatingBoundaryValidation {
+  boundary: RelationQueryOperatingBoundaryId;
+  kind: RelationQueryOperatingBoundaryValidationKind;
+  capabilityEvidence?: RelationQueryTargetCapabilityEvidenceId | null;
+  measuredValue?: string | null;
+}
+
+export type RelationQueryUnavailableReason = 'CapabilityNotAdvertised' | 'ProfileVersionUnsupported' | 'OperatingBoundaryMissing' | 'OperatingBoundaryInvalid' | 'CompositionUnavailable' | 'AmbiguousStrategy' | 'CapabilityEvidenceInvalid' | 'OverrideInvalid' | 'PolicyRejected' | 'PrerequisiteBlocked';
+
+export const relationQueryUnavailableReasons = {
+  capabilityNotAdvertised: 'CapabilityNotAdvertised',
+  profileVersionUnsupported: 'ProfileVersionUnsupported',
+  operatingBoundaryMissing: 'OperatingBoundaryMissing',
+  operatingBoundaryInvalid: 'OperatingBoundaryInvalid',
+  compositionUnavailable: 'CompositionUnavailable',
+  ambiguousStrategy: 'AmbiguousStrategy',
+  capabilityEvidenceInvalid: 'CapabilityEvidenceInvalid',
+  overrideInvalid: 'OverrideInvalid',
+  policyRejected: 'PolicyRejected',
+  prerequisiteBlocked: 'PrerequisiteBlocked',
+} as const satisfies Record<string, RelationQueryUnavailableReason>;
+
+export const relationQueryUnavailableReasonLabels: Record<RelationQueryUnavailableReason, string> = {
+  CapabilityNotAdvertised: 'CapabilityNotAdvertised',
+  ProfileVersionUnsupported: 'ProfileVersionUnsupported',
+  OperatingBoundaryMissing: 'OperatingBoundaryMissing',
+  OperatingBoundaryInvalid: 'OperatingBoundaryInvalid',
+  CompositionUnavailable: 'CompositionUnavailable',
+  AmbiguousStrategy: 'AmbiguousStrategy',
+  CapabilityEvidenceInvalid: 'CapabilityEvidenceInvalid',
+  OverrideInvalid: 'OverrideInvalid',
+  PolicyRejected: 'PolicyRejected',
+  PrerequisiteBlocked: 'PrerequisiteBlocked',
+};
+
+export type RelationQueryOperatingBoundaryKind = 'MaximumInputRows' | 'MaximumOutputRows' | 'MaximumFanOut' | 'MaximumPageSize' | 'MaximumFieldPathDepth' | 'MaximumExpressionDepth' | 'MaximumBatchSize' | 'SingleSource' | 'SinglePartition' | 'MaterializedInputs' | 'CompleteInputEvidence' | 'NonNullOperands' | 'ScalarOperands' | 'HomogeneousTemporalDomain' | 'FiniteTemporalBounds' | 'StableUniqueOrdering' | 'DeterministicProvider' | 'ExactNumericAggregateDomain' | 'ExactTemporalDomain' | 'SuppliedRelationRoot';
+
+export const relationQueryOperatingBoundaryKinds = {
+  maximumInputRows: 'MaximumInputRows',
+  maximumOutputRows: 'MaximumOutputRows',
+  maximumFanOut: 'MaximumFanOut',
+  maximumPageSize: 'MaximumPageSize',
+  maximumFieldPathDepth: 'MaximumFieldPathDepth',
+  maximumExpressionDepth: 'MaximumExpressionDepth',
+  maximumBatchSize: 'MaximumBatchSize',
+  singleSource: 'SingleSource',
+  singlePartition: 'SinglePartition',
+  materializedInputs: 'MaterializedInputs',
+  completeInputEvidence: 'CompleteInputEvidence',
+  nonNullOperands: 'NonNullOperands',
+  scalarOperands: 'ScalarOperands',
+  homogeneousTemporalDomain: 'HomogeneousTemporalDomain',
+  finiteTemporalBounds: 'FiniteTemporalBounds',
+  stableUniqueOrdering: 'StableUniqueOrdering',
+  deterministicProvider: 'DeterministicProvider',
+  exactNumericAggregateDomain: 'ExactNumericAggregateDomain',
+  exactTemporalDomain: 'ExactTemporalDomain',
+  suppliedRelationRoot: 'SuppliedRelationRoot',
+} as const satisfies Record<string, RelationQueryOperatingBoundaryKind>;
+
+export const relationQueryOperatingBoundaryKindLabels: Record<RelationQueryOperatingBoundaryKind, string> = {
+  MaximumInputRows: 'MaximumInputRows',
+  MaximumOutputRows: 'MaximumOutputRows',
+  MaximumFanOut: 'MaximumFanOut',
+  MaximumPageSize: 'MaximumPageSize',
+  MaximumFieldPathDepth: 'MaximumFieldPathDepth',
+  MaximumExpressionDepth: 'MaximumExpressionDepth',
+  MaximumBatchSize: 'MaximumBatchSize',
+  SingleSource: 'SingleSource',
+  SinglePartition: 'SinglePartition',
+  MaterializedInputs: 'MaterializedInputs',
+  CompleteInputEvidence: 'CompleteInputEvidence',
+  NonNullOperands: 'NonNullOperands',
+  ScalarOperands: 'ScalarOperands',
+  HomogeneousTemporalDomain: 'HomogeneousTemporalDomain',
+  FiniteTemporalBounds: 'FiniteTemporalBounds',
+  StableUniqueOrdering: 'StableUniqueOrdering',
+  DeterministicProvider: 'DeterministicProvider',
+  ExactNumericAggregateDomain: 'ExactNumericAggregateDomain',
+  ExactTemporalDomain: 'ExactTemporalDomain',
+  SuppliedRelationRoot: 'SuppliedRelationRoot',
+};
+
+export type RelationDraftId = string;
+
+export type RelationId = string;
+
+export type RelationName = string;
+
+export interface LogicalQueryDefinition {
+  nodes: LogicalQueryNode[];
+  parameters: QueryParameterDefinition[];
+}
+
+export interface RelationDraftProjection {
+  id: QueryNodeId;
+  input: QueryNodeId;
+  resultBinding: ValueBindingId;
+  resultShape: QualifiedShapeId;
+  assignments: RelationDraftAssignmentSlot[];
+}
+
+export type RelationOutputMode = 'OnePerRoot' | 'ZeroOrOnePerRoot' | 'ManyPerRoot' | 'Set';
+
+export const relationOutputModes = {
+  onePerRoot: 'OnePerRoot',
+  zeroOrOnePerRoot: 'ZeroOrOnePerRoot',
+  manyPerRoot: 'ManyPerRoot',
+  set: 'Set',
+} as const satisfies Record<string, RelationOutputMode>;
+
+export const relationOutputModeLabels: Record<RelationOutputMode, string> = {
+  OnePerRoot: 'OnePerRoot',
+  ZeroOrOnePerRoot: 'ZeroOrOnePerRoot',
+  ManyPerRoot: 'ManyPerRoot',
+  Set: 'Set',
+};
+
 export type Expr = {
+  readonly $expr: 'binding';
+} & BindingExpr | {
   readonly $expr: 'field';
 } & FieldExpr | {
   readonly $expr: 'currentItem';
@@ -53,177 +1073,820 @@ export type Expr = {
   readonly $expr: 'aggregate';
 } & AggregateExpr;
 
+export interface BindingExpr {
+  binding: ValueBindingId;
+}
+
 export interface FieldExpr {
-  Path: FieldPath;
+  path: FieldPath;
+  binding?: ValueBindingId | null;
 }
 
 export type CurrentItemExpr = Record<never, never>;
 
 export interface ParameterExpr {
-  Parameter: string;
+  parameter: string;
 }
 
 export interface ConstantExpr {
-  Value: unknown;
+  value: unknown;
 }
 
 export interface UnaryExpr {
-  Operator: UnaryOperator;
-  Operand: Expr;
+  operator: UnaryOperator;
+  operand: Expr;
 }
 
 export interface BinaryExpr {
-  Operator: BinaryOperator;
-  Left: Expr;
-  Right: Expr;
+  operator: BinaryOperator;
+  left: Expr;
+  right: Expr;
 }
 
 export interface ConditionalExpr {
-  Test: Expr;
-  IfTrue: Expr;
-  IfFalse: Expr;
-  ReturnType: TypeRef;
+  test: Expr;
+  ifTrue: Expr;
+  ifFalse: Expr;
+  returnType: TypeRef;
 }
 
 export interface CallExpr {
-  Function: string;
-  Arguments: Expr[];
-  ReturnType: TypeRef;
+  function: string;
+  arguments: Expr[];
+  returnType: TypeRef;
 }
 
 export interface FieldRefExpr {
-  Path: FieldPath;
-  Type: TypeRef;
+  path: FieldPath;
+  type: TypeRef;
 }
 
 export interface LiteralExpr {
-  Type: TypeRef;
-  Value: unknown;
+  type: TypeRef;
+  value: unknown;
 }
 
 export interface AggregateExpr {
-  Operator: AggregateOperator;
-  Source: Expr;
-  GroupBy: Expr[];
-  ReturnType: TypeRef;
-}
-
-export interface MappingDefinition {
-  Id: MappingId;
-  Name: MappingName;
-  Kind: MappingKind;
-  SourceShapeId?: ShapeId | null;
-  TargetShapeId: ShapeId;
-  Assignments: FieldAssignment[];
-  Predicate?: Expr | null;
-  ForEach?: Expr | null;
-  Key?: Expr | null;
-  Entity?: Expr | null;
-  Scope: MappingScope;
-  Direction: MappingDirection;
-  NestedMappings: NestedMapping[];
-  CollectionMappings: CollectionMapping[];
-  Metadata: MappingMetadata;
-}
-
-export interface MaterializationSpec {
-  IsEnabled: boolean;
-  Strategy: MaterializationStrategy;
-  Freshness: FreshnessPolicy;
-  AllowCodegen: boolean;
-}
-
-export interface RelationMetadata {
-  AllowCodegen: boolean;
-  Deterministic: boolean;
-  Hints: ({
-    Key: string;
-    Value: string;
-  })[];
+  operator: AggregateOperator;
+  source: Expr;
+  groupBy: Expr[];
+  returnType: TypeRef;
 }
 
 export interface InvariantDefinition {
-  Name: string;
-  Expression: Expr;
-  Message?: string | null;
+  name: string;
+  entity?: EntityId | null;
+  expression: Expr;
+  message?: string | null;
 }
 
-export interface SourceAlias {
-  Value: string;
+export type DocumentOrigin = 'Unknown' | 'User' | 'System' | 'Imported' | 'Generated' | 'Compiled' | 'Extracted';
+
+export const documentOrigins = {
+  unknown: 'Unknown',
+  user: 'User',
+  system: 'System',
+  imported: 'Imported',
+  generated: 'Generated',
+  compiled: 'Compiled',
+  extracted: 'Extracted',
+} as const satisfies Record<string, DocumentOrigin>;
+
+export const documentOriginLabels: Record<DocumentOrigin, string> = {
+  Unknown: 'Unknown',
+  User: 'User',
+  System: 'System',
+  Imported: 'Imported',
+  Generated: 'Generated',
+  Compiled: 'Compiled',
+  Extracted: 'Extracted',
+};
+
+export type AnnotationKey = string;
+
+export type AnnotationValue = unknown;
+
+export interface RelationDraftProducerArtifactReference {
+  kind: string;
+  value: string;
+}
+
+export interface RelationDraftConventionDecision {
+  ruleId: string;
+  slotId: QueryAssignmentId;
+  candidateId?: RelationDraftCandidateId | null;
+  sourceBinding: ValueBindingId;
+  source?: FieldPath | null;
+  target: FieldPath;
+}
+
+export interface RelationOutputDefinition {
+  node: QueryNodeId;
+  shape: QualifiedShapeId;
+  mode: RelationOutputMode;
+  key?: Expr | null;
 }
 
-export type SourceCardinality = 0 | 1;
+export type QueryId = string;
 
-export const sourceCardinalities = {
-  single: 0,
-  many: 1,
-} as const satisfies Record<string, SourceCardinality>;
+export type QueryName = string;
+
+export type QueryResultDefinition = {
+  readonly $result: 'rows';
+} & RowsQueryResultDefinition | {
+  readonly $result: 'aggregation';
+} & AggregationQueryResultDefinition;
+
+export interface RowsQueryResultDefinition {
+  id: QueryResultId;
+  input: QueryNodeId;
+}
+
+export interface AggregationQueryResultDefinition {
+  id: QueryResultId;
+  input: QueryNodeId;
+}
+
+export interface RelationshipDefinition {
+  id: RelationshipId;
+  sourceShape: QualifiedShapeId;
+  sourceReference: FieldPath;
+  targetShape: QualifiedShapeId;
+  targetKey: RelationshipTargetKey;
+  sourceReferenceUniqueness: SourceReferenceUniqueness;
+}
 
-export const sourceCardinalityLabels: Record<SourceCardinality, string> = {
-  0: 'Single',
-  1: 'Many',
+export interface RelationQueryLogicalPlan {
+  nodes: RelationQueryLogicalPlanNode[];
+  retainedNodes: QueryNodeId[];
+  evaluationOrder: QueryNodeId[];
+}
+
+export interface RelationQueryExplainRequirementGraph {
+  inputs: RelationQueryExplainRequirementInput[];
+  outputs: RelationQueryOutputReference[];
+  edges: RelationQueryExplainRequirementEdge[];
+}
+
+export interface RelationQueryNativeResultBranch {
+  id: RelationQueryNativeResultBranchId;
+  kind: RelationQueryNativeResultKind;
+  node: QueryNodeId;
+  binding: ValueBindingId;
+  shape: QualifiedShapeId;
+  relation?: RelationId | null;
+  queryResult?: QueryResultId | null;
+  outputs: RelationQueryOutputReference[];
+  fields: RelationQueryFieldReference[];
+}
+
+export interface DocumentDiagnosticEvidence {
+  stage?: string | null;
+  subject?: string | null;
+  relatedLocations: string[];
+  sourceReferences: string[];
+  resolutionOptions: string[];
+  expected?: string | null;
+  observed?: string | null;
+}
+
+export type RelationQueryPhysicalPlanningStatus = 'Planned' | 'Unavailable' | 'Invalid';
+
+export const relationQueryPhysicalPlanningStatuses = {
+  planned: 'Planned',
+  unavailable: 'Unavailable',
+  invalid: 'Invalid',
+} as const satisfies Record<string, RelationQueryPhysicalPlanningStatus>;
+
+export const relationQueryPhysicalPlanningStatusLabels: Record<RelationQueryPhysicalPlanningStatus, string> = {
+  Planned: 'Planned',
+  Unavailable: 'Unavailable',
+  Invalid: 'Invalid',
 };
 
-export type JoinKind = 0 | 1 | 2 | 3;
+export type RelationQueryNativeCompilationStatus = 'Exact' | 'Unsupported' | 'Invalid';
 
-export const joinKinds = {
-  inner: 0,
-  left: 1,
-  right: 2,
-  full: 3,
-} as const satisfies Record<string, JoinKind>;
+export const relationQueryNativeCompilationStatuses = {
+  exact: 'Exact',
+  unsupported: 'Unsupported',
+  invalid: 'Invalid',
+} as const satisfies Record<string, RelationQueryNativeCompilationStatus>;
 
-export const joinKindLabels: Record<JoinKind, string> = {
-  0: 'Inner',
-  1: 'Left',
-  2: 'Right',
-  3: 'Full',
+export const relationQueryNativeCompilationStatusLabels: Record<RelationQueryNativeCompilationStatus, string> = {
+  Exact: 'Exact',
+  Unsupported: 'Unsupported',
+  Invalid: 'Invalid',
 };
 
-export interface FieldPath {
-  Segments: FieldPathSegment[];
+export interface RelationQueryNativeArtifactReference {
+  branch: RelationQueryNativeResultBranchId;
+  artifactSchemaVersion?: string | null;
+  fingerprint: RelationQueryNativeArtifactFingerprintReference;
+  provenance: RelationQueryNativeCompilationProvenance;
+}
+
+export interface RelationQueryNativeCompilationDiagnostic {
+  code: string;
+  severity: DiagnosticSeverity;
+  message: string;
+  branch?: RelationQueryNativeResultBranchId | null;
+  node?: QueryNodeId | null;
+  input?: RelationQueryInputId | null;
+  requirement?: RelationQueryRealizationRequirementId | null;
+  capabilityEvidence?: RelationQueryTargetCapabilityEvidenceId | null;
+  operatingBoundary?: RelationQueryOperatingBoundaryId | null;
+  override?: RelationQueryRealizationOverrideId | null;
+  semanticSite?: string | null;
+  contextEvidence?: RelationQueryContextEvidenceId | null;
+  field?: FieldPath | null;
+  placementBinding?: RelationQuerySourcePlacementBindingId | null;
+  bindingSetting?: string | null;
+  resolution?: string | null;
+  configurationOrigin?: EffectiveConfigurationOrigin | null;
+  configurationAuthority?: string | null;
+  adapterDecisionCode?: RelationQueryAdapterDecisionCode | null;
+}
+
+export interface RelationQueryEvaluationFingerprint {
+  algorithm: string;
+  canonicalization: string;
+  value: string;
+}
+
+export type RelationQueryExecutionStatus = 'Succeeded' | 'Incomplete' | 'Failed';
+
+export const relationQueryExecutionStatuses = {
+  succeeded: 'Succeeded',
+  incomplete: 'Incomplete',
+  failed: 'Failed',
+} as const satisfies Record<string, RelationQueryExecutionStatus>;
+
+export const relationQueryExecutionStatusLabels: Record<RelationQueryExecutionStatus, string> = {
+  Succeeded: 'Succeeded',
+  Incomplete: 'Incomplete',
+  Failed: 'Failed',
+};
+
+export interface RelationQueryExplainResultSummary {
+  branch: RelationQueryNativeResultBranchId;
+  kind: RelationQueryExecutionResultKind;
+  shape: QualifiedShapeId;
+  state: RelationQueryExecutionOutputState;
+  rowCount: number;
+}
+
+export interface RelationQueryExplainRequirementGapSummary {
+  cause: RelationRequirementGapCause;
+  input: RelationQueryInputId;
+  affectedOutputs: RelationQueryOutputId[];
+  occurrenceCount: number;
+  suggestedResolutions: RelationRequirementGapResolutionKind[];
+}
+
+export interface RelationQueryEvaluationObservationFingerprint {
+  algorithm: string;
+  canonicalization: string;
+  value: string;
+}
+
+export interface FieldPathSegment {
+  kind: SegmentKind;
+  segment?: string | null;
+}
+
+export type RelationQueryPhysicalLoweringRuleId = string;
+
+export interface RelationQueryPhysicalCapabilityEvidenceReference {
+  source: RelationQuerySourceInstanceId;
+  target: RelationQueryTargetId;
+  profile: RelationQueryTargetProfileId;
+  evidence: RelationQueryTargetCapabilityEvidenceId;
+}
+
+export type RelationQueryPhysicalPlanningDecisionId = string;
+
+export interface RelationQueryAdapterBindingFingerprint {
+  algorithm: string;
+  canonicalization: string;
+  value: string;
+}
+
+export type RelationQueryBoundAssessmentStatus = 'Available' | 'Unavailable' | 'Invalid' | 'Blocked';
+
+export const relationQueryBoundAssessmentStatuses = {
+  available: 'Available',
+  unavailable: 'Unavailable',
+  invalid: 'Invalid',
+  blocked: 'Blocked',
+} as const satisfies Record<string, RelationQueryBoundAssessmentStatus>;
+
+export const relationQueryBoundAssessmentStatusLabels: Record<RelationQueryBoundAssessmentStatus, string> = {
+  Available: 'Available',
+  Unavailable: 'Unavailable',
+  Invalid: 'Invalid',
+  Blocked: 'Blocked',
+};
+
+export type RelationQueryLogicalCapabilityKind = 'Source' | 'Filter' | 'RelationshipTraversal' | 'ForwardRelationshipTraversal' | 'InverseRelationshipTraversal' | 'AtMostOneRelationshipTraversal' | 'ManyRelationshipTraversal' | 'RequiredRelationshipTraversal' | 'OptionalRelationshipTraversal' | 'Join' | 'InnerJoin' | 'LeftOuterJoin' | 'RightOuterJoin' | 'FullOuterJoin' | 'TemporalJoin' | 'ExpandCollection' | 'Projection' | 'ProjectionAssignment' | 'DistinctRows' | 'DistinctKeys' | 'Aggregation' | 'AggregateGrouping' | 'AggregateFilter' | 'CountAggregate' | 'SumAggregate' | 'MinimumAggregate' | 'MaximumAggregate' | 'AnyAggregate' | 'AllAggregate' | 'Ordering' | 'AscendingOrdering' | 'DescendingOrdering' | 'NullsFirst' | 'NullsLast' | 'StableTieOrdering' | 'OffsetPaging' | 'KeysetPaging' | 'OnePerRootRelationOutput' | 'ZeroOrOnePerRootRelationOutput' | 'ManyPerRootRelationOutput' | 'SetRelationOutput' | 'RelationOutputIdentity' | 'RelationInvariant' | 'QueryRowsResult' | 'QueryAggregationResult' | 'AlwaysPresentBinding' | 'MayBeAbsentBinding' | 'AverageAggregate';
+
+export const relationQueryLogicalCapabilityKinds = {
+  source: 'Source',
+  filter: 'Filter',
+  relationshipTraversal: 'RelationshipTraversal',
+  forwardRelationshipTraversal: 'ForwardRelationshipTraversal',
+  inverseRelationshipTraversal: 'InverseRelationshipTraversal',
+  atMostOneRelationshipTraversal: 'AtMostOneRelationshipTraversal',
+  manyRelationshipTraversal: 'ManyRelationshipTraversal',
+  requiredRelationshipTraversal: 'RequiredRelationshipTraversal',
+  optionalRelationshipTraversal: 'OptionalRelationshipTraversal',
+  join: 'Join',
+  innerJoin: 'InnerJoin',
+  leftOuterJoin: 'LeftOuterJoin',
+  rightOuterJoin: 'RightOuterJoin',
+  fullOuterJoin: 'FullOuterJoin',
+  temporalJoin: 'TemporalJoin',
+  expandCollection: 'ExpandCollection',
+  projection: 'Projection',
+  projectionAssignment: 'ProjectionAssignment',
+  distinctRows: 'DistinctRows',
+  distinctKeys: 'DistinctKeys',
+  aggregation: 'Aggregation',
+  aggregateGrouping: 'AggregateGrouping',
+  aggregateFilter: 'AggregateFilter',
+  countAggregate: 'CountAggregate',
+  sumAggregate: 'SumAggregate',
+  minimumAggregate: 'MinimumAggregate',
+  maximumAggregate: 'MaximumAggregate',
+  anyAggregate: 'AnyAggregate',
+  allAggregate: 'AllAggregate',
+  ordering: 'Ordering',
+  ascendingOrdering: 'AscendingOrdering',
+  descendingOrdering: 'DescendingOrdering',
+  nullsFirst: 'NullsFirst',
+  nullsLast: 'NullsLast',
+  stableTieOrdering: 'StableTieOrdering',
+  offsetPaging: 'OffsetPaging',
+  keysetPaging: 'KeysetPaging',
+  onePerRootRelationOutput: 'OnePerRootRelationOutput',
+  zeroOrOnePerRootRelationOutput: 'ZeroOrOnePerRootRelationOutput',
+  manyPerRootRelationOutput: 'ManyPerRootRelationOutput',
+  setRelationOutput: 'SetRelationOutput',
+  relationOutputIdentity: 'RelationOutputIdentity',
+  relationInvariant: 'RelationInvariant',
+  queryRowsResult: 'QueryRowsResult',
+  queryAggregationResult: 'QueryAggregationResult',
+  alwaysPresentBinding: 'AlwaysPresentBinding',
+  mayBeAbsentBinding: 'MayBeAbsentBinding',
+  averageAggregate: 'AverageAggregate',
+} as const satisfies Record<string, RelationQueryLogicalCapabilityKind>;
+
+export const relationQueryLogicalCapabilityKindLabels: Record<RelationQueryLogicalCapabilityKind, string> = {
+  Source: 'Source',
+  Filter: 'Filter',
+  RelationshipTraversal: 'RelationshipTraversal',
+  ForwardRelationshipTraversal: 'ForwardRelationshipTraversal',
+  InverseRelationshipTraversal: 'InverseRelationshipTraversal',
+  AtMostOneRelationshipTraversal: 'AtMostOneRelationshipTraversal',
+  ManyRelationshipTraversal: 'ManyRelationshipTraversal',
+  RequiredRelationshipTraversal: 'RequiredRelationshipTraversal',
+  OptionalRelationshipTraversal: 'OptionalRelationshipTraversal',
+  Join: 'Join',
+  InnerJoin: 'InnerJoin',
+  LeftOuterJoin: 'LeftOuterJoin',
+  RightOuterJoin: 'RightOuterJoin',
+  FullOuterJoin: 'FullOuterJoin',
+  TemporalJoin: 'TemporalJoin',
+  ExpandCollection: 'ExpandCollection',
+  Projection: 'Projection',
+  ProjectionAssignment: 'ProjectionAssignment',
+  DistinctRows: 'DistinctRows',
+  DistinctKeys: 'DistinctKeys',
+  Aggregation: 'Aggregation',
+  AggregateGrouping: 'AggregateGrouping',
+  AggregateFilter: 'AggregateFilter',
+  CountAggregate: 'CountAggregate',
+  SumAggregate: 'SumAggregate',
+  MinimumAggregate: 'MinimumAggregate',
+  MaximumAggregate: 'MaximumAggregate',
+  AnyAggregate: 'AnyAggregate',
+  AllAggregate: 'AllAggregate',
+  Ordering: 'Ordering',
+  AscendingOrdering: 'AscendingOrdering',
+  DescendingOrdering: 'DescendingOrdering',
+  NullsFirst: 'NullsFirst',
+  NullsLast: 'NullsLast',
+  StableTieOrdering: 'StableTieOrdering',
+  OffsetPaging: 'OffsetPaging',
+  KeysetPaging: 'KeysetPaging',
+  OnePerRootRelationOutput: 'OnePerRootRelationOutput',
+  ZeroOrOnePerRootRelationOutput: 'ZeroOrOnePerRootRelationOutput',
+  ManyPerRootRelationOutput: 'ManyPerRootRelationOutput',
+  SetRelationOutput: 'SetRelationOutput',
+  RelationOutputIdentity: 'RelationOutputIdentity',
+  RelationInvariant: 'RelationInvariant',
+  QueryRowsResult: 'QueryRowsResult',
+  QueryAggregationResult: 'QueryAggregationResult',
+  AlwaysPresentBinding: 'AlwaysPresentBinding',
+  MayBeAbsentBinding: 'MayBeAbsentBinding',
+  AverageAggregate: 'AverageAggregate',
+};
+
+export interface ExprCapabilityId {
+  value: string;
 }
 
-export type UnaryOperator = 0;
+export type ExprCapabilityRequirementKind = 'Operation' | 'Ambient';
+
+export const exprCapabilityRequirementKinds = {
+  operation: 'Operation',
+  ambient: 'Ambient',
+} as const satisfies Record<string, ExprCapabilityRequirementKind>;
+
+export const exprCapabilityRequirementKindLabels: Record<ExprCapabilityRequirementKind, string> = {
+  Operation: 'Operation',
+  Ambient: 'Ambient',
+};
+
+export type RelationQueryTemporalExecutionCapability = 'PointInInterval' | 'IntervalOverlap' | 'InclusiveBoundary' | 'ExclusiveBoundary' | 'UnboundedBoundary' | 'NullAsUnbounded' | 'DateDomain' | 'DateTimeDomain' | 'InstantDomain' | 'PreserveAllMatches' | 'InnerJoin' | 'LeftOuterJoin' | 'RightOuterJoin' | 'FullOuterJoin' | 'ValidateIntervals' | 'InconclusiveEvidence';
+
+export const relationQueryTemporalExecutionCapabilities = {
+  pointInInterval: 'PointInInterval',
+  intervalOverlap: 'IntervalOverlap',
+  inclusiveBoundary: 'InclusiveBoundary',
+  exclusiveBoundary: 'ExclusiveBoundary',
+  unboundedBoundary: 'UnboundedBoundary',
+  nullAsUnbounded: 'NullAsUnbounded',
+  dateDomain: 'DateDomain',
+  dateTimeDomain: 'DateTimeDomain',
+  instantDomain: 'InstantDomain',
+  preserveAllMatches: 'PreserveAllMatches',
+  innerJoin: 'InnerJoin',
+  leftOuterJoin: 'LeftOuterJoin',
+  rightOuterJoin: 'RightOuterJoin',
+  fullOuterJoin: 'FullOuterJoin',
+  validateIntervals: 'ValidateIntervals',
+  inconclusiveEvidence: 'InconclusiveEvidence',
+} as const satisfies Record<string, RelationQueryTemporalExecutionCapability>;
+
+export const relationQueryTemporalExecutionCapabilityLabels: Record<RelationQueryTemporalExecutionCapability, string> = {
+  PointInInterval: 'PointInInterval',
+  IntervalOverlap: 'IntervalOverlap',
+  InclusiveBoundary: 'InclusiveBoundary',
+  ExclusiveBoundary: 'ExclusiveBoundary',
+  UnboundedBoundary: 'UnboundedBoundary',
+  NullAsUnbounded: 'NullAsUnbounded',
+  DateDomain: 'DateDomain',
+  DateTimeDomain: 'DateTimeDomain',
+  InstantDomain: 'InstantDomain',
+  PreserveAllMatches: 'PreserveAllMatches',
+  InnerJoin: 'InnerJoin',
+  LeftOuterJoin: 'LeftOuterJoin',
+  RightOuterJoin: 'RightOuterJoin',
+  FullOuterJoin: 'FullOuterJoin',
+  ValidateIntervals: 'ValidateIntervals',
+  InconclusiveEvidence: 'InconclusiveEvidence',
+};
+
+export type RelationQueryStructuralCapabilityRole = 'BindingRead' | 'CurrentItemRead' | 'OccurrenceEvidenceReconstruction' | 'ProjectionTarget' | 'GroupingTarget' | 'AggregateTarget' | 'OutputSelection' | 'CompleteValue';
+
+export const relationQueryStructuralCapabilityRoles = {
+  bindingRead: 'BindingRead',
+  currentItemRead: 'CurrentItemRead',
+  occurrenceEvidenceReconstruction: 'OccurrenceEvidenceReconstruction',
+  projectionTarget: 'ProjectionTarget',
+  groupingTarget: 'GroupingTarget',
+  aggregateTarget: 'AggregateTarget',
+  outputSelection: 'OutputSelection',
+  completeValue: 'CompleteValue',
+} as const satisfies Record<string, RelationQueryStructuralCapabilityRole>;
+
+export const relationQueryStructuralCapabilityRoleLabels: Record<RelationQueryStructuralCapabilityRole, string> = {
+  BindingRead: 'BindingRead',
+  CurrentItemRead: 'CurrentItemRead',
+  OccurrenceEvidenceReconstruction: 'OccurrenceEvidenceReconstruction',
+  ProjectionTarget: 'ProjectionTarget',
+  GroupingTarget: 'GroupingTarget',
+  AggregateTarget: 'AggregateTarget',
+  OutputSelection: 'OutputSelection',
+  CompleteValue: 'CompleteValue',
+};
+
+export type RelationQueryStructuralPathKind = 'RootValue' | 'TopLevelField' | 'NestedField' | 'CollectionElement' | 'NestedCollectionElement';
+
+export const relationQueryStructuralPathKinds = {
+  rootValue: 'RootValue',
+  topLevelField: 'TopLevelField',
+  nestedField: 'NestedField',
+  collectionElement: 'CollectionElement',
+  nestedCollectionElement: 'NestedCollectionElement',
+} as const satisfies Record<string, RelationQueryStructuralPathKind>;
+
+export const relationQueryStructuralPathKindLabels: Record<RelationQueryStructuralPathKind, string> = {
+  RootValue: 'RootValue',
+  TopLevelField: 'TopLevelField',
+  NestedField: 'NestedField',
+  CollectionElement: 'CollectionElement',
+  NestedCollectionElement: 'NestedCollectionElement',
+};
+
+export type RelationQueryPrimitiveCapabilityKind = 'KeyExtraction' | 'BatchedKeyLookup' | 'PredicateRead' | 'CompleteSetEnumeration' | 'LocalCorrelation' | 'HashJoin' | 'StableSort' | 'LocalAggregation' | 'FieldProjection' | 'NullAwareComparison' | 'TemporalComparison' | 'IntervalPredicate' | 'ObservationIdentityRead' | 'RelationshipReferenceRead' | 'ParameterBinding' | 'AmbientCapabilityBinding' | 'OutputObjectConstruction' | 'ProvenanceTracking' | 'BatchedPredicateLookup' | 'InvariantEvaluation' | 'OffsetPaging' | 'KeysetSeek';
+
+export const relationQueryPrimitiveCapabilityKinds = {
+  keyExtraction: 'KeyExtraction',
+  batchedKeyLookup: 'BatchedKeyLookup',
+  predicateRead: 'PredicateRead',
+  completeSetEnumeration: 'CompleteSetEnumeration',
+  localCorrelation: 'LocalCorrelation',
+  hashJoin: 'HashJoin',
+  stableSort: 'StableSort',
+  localAggregation: 'LocalAggregation',
+  fieldProjection: 'FieldProjection',
+  nullAwareComparison: 'NullAwareComparison',
+  temporalComparison: 'TemporalComparison',
+  intervalPredicate: 'IntervalPredicate',
+  observationIdentityRead: 'ObservationIdentityRead',
+  relationshipReferenceRead: 'RelationshipReferenceRead',
+  parameterBinding: 'ParameterBinding',
+  ambientCapabilityBinding: 'AmbientCapabilityBinding',
+  outputObjectConstruction: 'OutputObjectConstruction',
+  provenanceTracking: 'ProvenanceTracking',
+  batchedPredicateLookup: 'BatchedPredicateLookup',
+  invariantEvaluation: 'InvariantEvaluation',
+  offsetPaging: 'OffsetPaging',
+  keysetSeek: 'KeysetSeek',
+} as const satisfies Record<string, RelationQueryPrimitiveCapabilityKind>;
+
+export const relationQueryPrimitiveCapabilityKindLabels: Record<RelationQueryPrimitiveCapabilityKind, string> = {
+  KeyExtraction: 'KeyExtraction',
+  BatchedKeyLookup: 'BatchedKeyLookup',
+  PredicateRead: 'PredicateRead',
+  CompleteSetEnumeration: 'CompleteSetEnumeration',
+  LocalCorrelation: 'LocalCorrelation',
+  HashJoin: 'HashJoin',
+  StableSort: 'StableSort',
+  LocalAggregation: 'LocalAggregation',
+  FieldProjection: 'FieldProjection',
+  NullAwareComparison: 'NullAwareComparison',
+  TemporalComparison: 'TemporalComparison',
+  IntervalPredicate: 'IntervalPredicate',
+  ObservationIdentityRead: 'ObservationIdentityRead',
+  RelationshipReferenceRead: 'RelationshipReferenceRead',
+  ParameterBinding: 'ParameterBinding',
+  AmbientCapabilityBinding: 'AmbientCapabilityBinding',
+  OutputObjectConstruction: 'OutputObjectConstruction',
+  ProvenanceTracking: 'ProvenanceTracking',
+  BatchedPredicateLookup: 'BatchedPredicateLookup',
+  InvariantEvaluation: 'InvariantEvaluation',
+  OffsetPaging: 'OffsetPaging',
+  KeysetSeek: 'KeysetSeek',
+};
+
+export interface RelationQueryRealizationOutputReference {
+  id: RelationQueryOutputId;
+  kind: RelationQueryOutputReferenceKind;
+  node: QueryNodeId;
+  shape: QualifiedShapeId;
+  relation?: RelationId | null;
+  queryResult?: QueryResultId | null;
+  field?: RelationQueryFieldReference | null;
+}
+
+export type RelationQueryRequirementEffect = 'Value' | 'Identity' | 'Membership' | 'Correlation' | 'Acquisition' | 'Cardinality' | 'Ordering' | 'Grouping' | 'Aggregation' | 'Pagination' | 'Validation' | 'Evaluation';
+
+export const relationQueryRequirementEffects = {
+  value: 'Value',
+  identity: 'Identity',
+  membership: 'Membership',
+  correlation: 'Correlation',
+  acquisition: 'Acquisition',
+  cardinality: 'Cardinality',
+  ordering: 'Ordering',
+  grouping: 'Grouping',
+  aggregation: 'Aggregation',
+  pagination: 'Pagination',
+  validation: 'Validation',
+  evaluation: 'Evaluation',
+} as const satisfies Record<string, RelationQueryRequirementEffect>;
+
+export const relationQueryRequirementEffectLabels: Record<RelationQueryRequirementEffect, string> = {
+  Value: 'Value',
+  Identity: 'Identity',
+  Membership: 'Membership',
+  Correlation: 'Correlation',
+  Acquisition: 'Acquisition',
+  Cardinality: 'Cardinality',
+  Ordering: 'Ordering',
+  Grouping: 'Grouping',
+  Aggregation: 'Aggregation',
+  Pagination: 'Pagination',
+  Validation: 'Validation',
+  Evaluation: 'Evaluation',
+};
+
+export type QueryInputRequirement = 'Optional' | 'Required';
+
+export const queryInputRequirements = {
+  optional: 'Optional',
+  required: 'Required',
+} as const satisfies Record<string, QueryInputRequirement>;
+
+export const queryInputRequirementLabels: Record<QueryInputRequirement, string> = {
+  Optional: 'Optional',
+  Required: 'Required',
+};
+
+export interface RelationQueryRealizationTrace {
+  steps: RelationQueryRealizationTraceStep[];
+}
+
+export type RelationQueryRealizationStaticFactKind = 'FieldPathDepth' | 'ExpressionDepth' | 'PageSize';
+
+export const relationQueryRealizationStaticFactKinds = {
+  fieldPathDepth: 'FieldPathDepth',
+  expressionDepth: 'ExpressionDepth',
+  pageSize: 'PageSize',
+} as const satisfies Record<string, RelationQueryRealizationStaticFactKind>;
+
+export const relationQueryRealizationStaticFactKindLabels: Record<RelationQueryRealizationStaticFactKind, string> = {
+  FieldPathDepth: 'FieldPathDepth',
+  ExpressionDepth: 'ExpressionDepth',
+  PageSize: 'PageSize',
+};
+
+export type RelationQueryOperatingBoundaryValidationKind = 'StaticPlanFact' | 'TargetEnforced';
+
+export const relationQueryOperatingBoundaryValidationKinds = {
+  staticPlanFact: 'StaticPlanFact',
+  targetEnforced: 'TargetEnforced',
+} as const satisfies Record<string, RelationQueryOperatingBoundaryValidationKind>;
+
+export const relationQueryOperatingBoundaryValidationKindLabels: Record<RelationQueryOperatingBoundaryValidationKind, string> = {
+  StaticPlanFact: 'StaticPlanFact',
+  TargetEnforced: 'TargetEnforced',
+};
+
+export type LogicalQueryNode = {
+  readonly $node: 'source';
+} & SourceQueryNode | {
+  readonly $node: 'filter';
+} & FilterQueryNode | {
+  readonly $node: 'traverseRelationship';
+} & TraverseRelationshipQueryNode | {
+  readonly $node: 'join';
+} & JoinQueryNode | {
+  readonly $node: 'temporalJoin';
+} & TemporalJoinQueryNode | {
+  readonly $node: 'expandCollection';
+} & ExpandCollectionQueryNode | {
+  readonly $node: 'project';
+} & ProjectQueryNode | {
+  readonly $node: 'distinct';
+} & DistinctQueryNode | {
+  readonly $node: 'aggregate';
+} & AggregateQueryNode | {
+  readonly $node: 'order';
+} & OrderQueryNode | {
+  readonly $node: 'page';
+} & PageQueryNode;
+
+export interface SourceQueryNode {
+  id: QueryNodeId;
+  binding: ValueBindingId;
+  shape: QualifiedShapeId;
+}
+
+export interface FilterQueryNode {
+  input: QueryNodeId;
+  predicate: Expr;
+  id: QueryNodeId;
+}
+
+export interface TraverseRelationshipQueryNode {
+  id: QueryNodeId;
+  input: QueryNodeId;
+  from: ValueBindingId;
+  relationship: RelationshipId;
+  direction: RelationshipTraversalDirection;
+  result: ValueBindingId;
+  joinKind: JoinKind;
+  requirement: QueryInputRequirement;
+}
+
+export interface JoinQueryNode {
+  left: QueryNodeId;
+  right: QueryNodeId;
+  kind: JoinKind;
+  predicate: Expr;
+  id: QueryNodeId;
+}
+
+export interface TemporalJoinQueryNode {
+  id: QueryNodeId;
+  left: QueryNodeId;
+  right: QueryNodeId;
+  kind: JoinKind;
+  correlation: Expr;
+  match: TemporalJoinMatch;
+}
+
+export interface ExpandCollectionQueryNode {
+  input: QueryNodeId;
+  collection: Expr;
+  itemBinding: ValueBindingId;
+  itemType: TypeRef;
+  id: QueryNodeId;
+}
+
+export interface ProjectQueryNode {
+  id: QueryNodeId;
+  input: QueryNodeId;
+  resultBinding: ValueBindingId;
+  resultShape: QualifiedShapeId;
+  assignments: ProjectionAssignment[];
+}
+
+export interface DistinctQueryNode {
+  input: QueryNodeId;
+  keys: Expr[];
+  id: QueryNodeId;
+}
+
+export interface AggregateQueryNode {
+  input: QueryNodeId;
+  resultBinding: ValueBindingId;
+  resultShape: QualifiedShapeId;
+  groupings: QueryGrouping[];
+  aggregates: QueryAggregateAssignment[];
+  id: QueryNodeId;
+}
+
+export interface OrderQueryNode {
+  id: QueryNodeId;
+  input: QueryNodeId;
+  orderings: QueryOrdering[];
+}
+
+export interface PageQueryNode {
+  id: QueryNodeId;
+  input: QueryNodeId;
+  page: QueryPageDefinition;
+}
+
+export interface QueryParameterDefinition {
+  id: QueryParameterId;
+  type: TypeRef;
+  presence: FieldPresence;
+  defaultKind: QueryParameterDefaultKind;
+  defaultValue?: unknown | null;
+}
+
+export interface RelationDraftAssignmentSlot {
+  id: QueryAssignmentId;
+  target: FieldPath;
+  candidates: RelationDraftCandidate[];
+  resolution: RelationDraftAssignmentResolution;
+}
+
+export type UnaryOperator = 'Not';
 
 export const unaryOperators = {
-  not: 0,
+  not: 'Not',
 } as const satisfies Record<string, UnaryOperator>;
 
 export const unaryOperatorLabels: Record<UnaryOperator, string> = {
-  0: 'Not',
+  Not: 'Not',
 };
 
-export type BinaryOperator = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
+export type BinaryOperator = 'Eq' | 'Ne' | 'Gt' | 'Ge' | 'Lt' | 'Le' | 'And' | 'Or' | 'Add' | 'Sub' | 'Mul' | 'Div';
 
 export const binaryOperators = {
-  eq: 0,
-  ne: 1,
-  gt: 2,
-  ge: 3,
-  lt: 4,
-  le: 5,
-  and: 6,
-  or: 7,
-  add: 8,
-  sub: 9,
-  mul: 10,
-  div: 11,
+  eq: 'Eq',
+  ne: 'Ne',
+  gt: 'Gt',
+  ge: 'Ge',
+  lt: 'Lt',
+  le: 'Le',
+  and: 'And',
+  or: 'Or',
+  add: 'Add',
+  sub: 'Sub',
+  mul: 'Mul',
+  div: 'Div',
 } as const satisfies Record<string, BinaryOperator>;
 
 export const binaryOperatorLabels: Record<BinaryOperator, string> = {
-  0: 'Eq',
-  1: 'Ne',
-  2: 'Gt',
-  3: 'Ge',
-  4: 'Lt',
-  5: 'Le',
-  6: 'And',
-  7: 'Or',
-  8: 'Add',
-  9: 'Sub',
-  10: 'Mul',
-  11: 'Div',
+  Eq: 'Eq',
+  Ne: 'Ne',
+  Gt: 'Gt',
+  Ge: 'Ge',
+  Lt: 'Lt',
+  Le: 'Le',
+  And: 'And',
+  Or: 'Or',
+  Add: 'Add',
+  Sub: 'Sub',
+  Mul: 'Mul',
+  Div: 'Div',
 };
 
 export type TypeRef = {
@@ -247,328 +1910,881 @@ export type TypeRef = {
 } & JsonTypeRef;
 
 export interface NamedTypeRef {
-  TypeId: TypeId;
+  typeId: TypeId;
 }
 
 export interface OpaqueRuntimeTypeRef {
-  RuntimeType: string;
+  runtimeType: string;
+  inferenceDiagnostic?: TypeInferenceDiagnostic | null;
 }
 
 export interface ScalarTypeRef {
-  Kind: ScalarTypeKind;
-  Format: PrimitiveFormat;
+  kind: ScalarTypeKind;
+  format: PrimitiveFormat;
 }
 
 export interface EnumTypeRef {
-  Name: string;
-  Members: string[];
+  name: string;
+  members: string[];
 }
 
 export interface EntityReferenceTypeRef {
-  Entity: EntityTypeName;
+  entity: EntityTypeName;
 }
 
 export interface ArrayTypeRef {
-  ElementType: TypeRef;
+  elementType: TypeRef;
 }
 
 export interface ObjectTypeRef {
-  Fields: ObjectFieldTypeDef[];
+  fields: ObjectFieldTypeDef[];
 }
 
 export interface QuantityTypeRef {
-  Quantity: string;
-  BaseKind: ScalarTypeKind;
+  quantity: string;
+  baseKind: ScalarTypeKind;
 }
 
 export interface JsonTypeRef {
-  Kind: JsonTypeKind;
+  kind: JsonTypeKind;
 }
 
-export type AggregateOperator = 0 | 1 | 2 | 3 | 4 | 5;
+export type AggregateOperator = 'Count' | 'Sum' | 'Min' | 'Max' | 'Any' | 'All' | 'Average';
 
 export const aggregateOperators = {
-  count: 0,
-  sum: 1,
-  min: 2,
-  max: 3,
-  any: 4,
-  all: 5,
+  count: 'Count',
+  sum: 'Sum',
+  min: 'Min',
+  max: 'Max',
+  any: 'Any',
+  all: 'All',
+  average: 'Average',
 } as const satisfies Record<string, AggregateOperator>;
 
 export const aggregateOperatorLabels: Record<AggregateOperator, string> = {
-  0: 'Count',
-  1: 'Sum',
-  2: 'Min',
-  3: 'Max',
-  4: 'Any',
-  5: 'All',
+  Count: 'Count',
+  Sum: 'Sum',
+  Min: 'Min',
+  Max: 'Max',
+  Any: 'Any',
+  All: 'All',
+  Average: 'Average',
+};
+
+export type EntityId = string;
+
+export type QueryAssignmentId = string;
+
+export type RelationDraftCandidateId = string;
+
+export type QueryResultId = string;
+
+export type RelationshipId = string;
+
+export type RelationshipTargetKey = {
+  readonly $targetKey: 'observationIdentity';
+} & ObservationIdentityRelationshipTargetKey;
+
+export type ObservationIdentityRelationshipTargetKey = Record<never, never>;
+
+export type SourceReferenceUniqueness = 'NotGuaranteed' | 'GloballyUnique';
+
+export const sourceReferenceUniquenesses = {
+  notGuaranteed: 'NotGuaranteed',
+  globallyUnique: 'GloballyUnique',
+} as const satisfies Record<string, SourceReferenceUniqueness>;
+
+export const sourceReferenceUniquenessLabels: Record<SourceReferenceUniqueness, string> = {
+  NotGuaranteed: 'NotGuaranteed',
+  GloballyUnique: 'GloballyUnique',
+};
+
+export interface RelationQueryLogicalPlanNode {
+  node: QueryNodeId;
+  inputs: RelationQueryLogicalPlanInput[];
+  effectiveInputs: QueryNodeId[];
+}
+
+export interface RelationQueryExplainRequirementInput {
+  id: RelationQueryInputId;
+  kind: RelationQueryExplainRequirementInputKind;
+}
+
+export interface RelationQueryOutputReference {
+  id: RelationQueryOutputId;
+  kind: RelationQueryOutputReferenceKind;
+  node: QueryNodeId;
+  shape: QualifiedShapeId;
+  relation?: RelationId | null;
+  queryResult?: QueryResultId | null;
+  field?: RelationQueryFieldReference | null;
+}
+
+export interface RelationQueryExplainRequirementEdge {
+  input: RelationQueryInputId;
+  output: RelationQueryOutputId;
+  effect: RelationQueryRequirementEffect;
+  requirement: QueryInputRequirement;
+}
+
+export type RelationQueryNativeResultKind = 'RelationRows' | 'QueryRows' | 'QueryAggregation';
+
+export const relationQueryNativeResultKinds = {
+  relationRows: 'RelationRows',
+  queryRows: 'QueryRows',
+  queryAggregation: 'QueryAggregation',
+} as const satisfies Record<string, RelationQueryNativeResultKind>;
+
+export const relationQueryNativeResultKindLabels: Record<RelationQueryNativeResultKind, string> = {
+  RelationRows: 'RelationRows',
+  QueryRows: 'QueryRows',
+  QueryAggregation: 'QueryAggregation',
 };
 
-export interface MappingId {
-  Value: string;
+export interface RelationQueryFieldReference {
+  shape: QualifiedShapeId;
+  path: FieldPath;
+}
+
+export interface RelationQueryNativeArtifactFingerprintReference {
+  algorithm: string;
+  canonicalization: string;
+  value: string;
 }
 
-export interface MappingName {
-  Value: string;
+export interface RelationQueryNativeCompilationProvenance {
+  plan: RelationQueryCompiledPlanReference;
+  branch: RelationQueryNativeResultBranchId;
+  target: RelationQueryTargetId;
+  targetProfile: RelationQueryTargetProfileId;
+  realization: RelationQueryRealizationFingerprint;
+  boundRealization: RelationQueryBoundRealizationFingerprint;
+  placement: RelationQuerySourcePlacementFingerprint;
+  adapterBinding: RelationQueryAdapterBindingReference;
+  contextEvidence: RelationQueryContextEvidenceId[];
+  compilerProfile: string;
+  conventionSetVersion: string;
+  coveredNodes: QueryNodeId[];
+  coveredAssignments: QueryAssignmentId[];
+  inputFields: RelationQueryInputId[];
+  realizationDecisions: RelationQueryNativeCompilationDecisionReference[];
+  capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+  operatingBoundaries: RelationQueryOperatingBoundaryId[];
 }
 
-export type MappingKind = 0 | 1;
+export type RelationQueryExecutionResultKind = 'Rows' | 'Aggregation';
+
+export const relationQueryExecutionResultKinds = {
+  rows: 'Rows',
+  aggregation: 'Aggregation',
+} as const satisfies Record<string, RelationQueryExecutionResultKind>;
+
+export const relationQueryExecutionResultKindLabels: Record<RelationQueryExecutionResultKind, string> = {
+  Rows: 'Rows',
+  Aggregation: 'Aggregation',
+};
+
+export type RelationQueryExecutionOutputState = 'Complete' | 'Suppressed' | 'Incomplete';
+
+export const relationQueryExecutionOutputStates = {
+  complete: 'Complete',
+  suppressed: 'Suppressed',
+  incomplete: 'Incomplete',
+} as const satisfies Record<string, RelationQueryExecutionOutputState>;
+
+export const relationQueryExecutionOutputStateLabels: Record<RelationQueryExecutionOutputState, string> = {
+  Complete: 'Complete',
+  Suppressed: 'Suppressed',
+  Incomplete: 'Incomplete',
+};
+
+export type RelationRequirementGapCause = 'InputNotProvided' | 'InputAcquisitionFailed' | 'ObservationIdentityMissing' | 'ReferenceFieldNotLoaded' | 'ReferenceValueMissing' | 'ReferenceValueNull' | 'ResolutionNotAttempted' | 'ResolutionFailed' | 'RelatedObservationNotFound' | 'RelatedObservationRejected' | 'RequiredFieldNotLoaded' | 'RequiredValueMissing' | 'RequiredValueNull' | 'CapabilityUnavailable' | 'CardinalityViolation' | 'ConversionFailure' | 'InputAcquisitionInconclusive';
+
+export const relationRequirementGapCauses = {
+  inputNotProvided: 'InputNotProvided',
+  inputAcquisitionFailed: 'InputAcquisitionFailed',
+  observationIdentityMissing: 'ObservationIdentityMissing',
+  referenceFieldNotLoaded: 'ReferenceFieldNotLoaded',
+  referenceValueMissing: 'ReferenceValueMissing',
+  referenceValueNull: 'ReferenceValueNull',
+  resolutionNotAttempted: 'ResolutionNotAttempted',
+  resolutionFailed: 'ResolutionFailed',
+  relatedObservationNotFound: 'RelatedObservationNotFound',
+  relatedObservationRejected: 'RelatedObservationRejected',
+  requiredFieldNotLoaded: 'RequiredFieldNotLoaded',
+  requiredValueMissing: 'RequiredValueMissing',
+  requiredValueNull: 'RequiredValueNull',
+  capabilityUnavailable: 'CapabilityUnavailable',
+  cardinalityViolation: 'CardinalityViolation',
+  conversionFailure: 'ConversionFailure',
+  inputAcquisitionInconclusive: 'InputAcquisitionInconclusive',
+} as const satisfies Record<string, RelationRequirementGapCause>;
+
+export const relationRequirementGapCauseLabels: Record<RelationRequirementGapCause, string> = {
+  InputNotProvided: 'InputNotProvided',
+  InputAcquisitionFailed: 'InputAcquisitionFailed',
+  ObservationIdentityMissing: 'ObservationIdentityMissing',
+  ReferenceFieldNotLoaded: 'ReferenceFieldNotLoaded',
+  ReferenceValueMissing: 'ReferenceValueMissing',
+  ReferenceValueNull: 'ReferenceValueNull',
+  ResolutionNotAttempted: 'ResolutionNotAttempted',
+  ResolutionFailed: 'ResolutionFailed',
+  RelatedObservationNotFound: 'RelatedObservationNotFound',
+  RelatedObservationRejected: 'RelatedObservationRejected',
+  RequiredFieldNotLoaded: 'RequiredFieldNotLoaded',
+  RequiredValueMissing: 'RequiredValueMissing',
+  RequiredValueNull: 'RequiredValueNull',
+  CapabilityUnavailable: 'CapabilityUnavailable',
+  CardinalityViolation: 'CardinalityViolation',
+  ConversionFailure: 'ConversionFailure',
+  InputAcquisitionInconclusive: 'InputAcquisitionInconclusive',
+};
+
+export type RelationRequirementGapResolutionKind = 'ProvideInput' | 'LoadField' | 'ProvideReferenceValue' | 'ResolveRelationship' | 'RetryAcquisition' | 'ProvideRelatedObservation' | 'CorrectCardinality' | 'ProvideValue' | 'ProvideCapability' | 'CorrectConversion';
+
+export const relationRequirementGapResolutionKinds = {
+  provideInput: 'ProvideInput',
+  loadField: 'LoadField',
+  provideReferenceValue: 'ProvideReferenceValue',
+  resolveRelationship: 'ResolveRelationship',
+  retryAcquisition: 'RetryAcquisition',
+  provideRelatedObservation: 'ProvideRelatedObservation',
+  correctCardinality: 'CorrectCardinality',
+  provideValue: 'ProvideValue',
+  provideCapability: 'ProvideCapability',
+  correctConversion: 'CorrectConversion',
+} as const satisfies Record<string, RelationRequirementGapResolutionKind>;
+
+export const relationRequirementGapResolutionKindLabels: Record<RelationRequirementGapResolutionKind, string> = {
+  ProvideInput: 'ProvideInput',
+  LoadField: 'LoadField',
+  ProvideReferenceValue: 'ProvideReferenceValue',
+  ResolveRelationship: 'ResolveRelationship',
+  RetryAcquisition: 'RetryAcquisition',
+  ProvideRelatedObservation: 'ProvideRelatedObservation',
+  CorrectCardinality: 'CorrectCardinality',
+  ProvideValue: 'ProvideValue',
+  ProvideCapability: 'ProvideCapability',
+  CorrectConversion: 'CorrectConversion',
+};
+
+export type SegmentKind = 'Field' | 'Element';
 
-export const mappingKinds = {
-  relation: 0,
-  object: 1,
-} as const satisfies Record<string, MappingKind>;
+export const segmentKinds = {
+  field: 'Field',
+  element: 'Element',
+} as const satisfies Record<string, SegmentKind>;
 
-export const mappingKindLabels: Record<MappingKind, string> = {
-  0: 'Relation',
-  1: 'Object',
+export const segmentKindLabels: Record<SegmentKind, string> = {
+  Field: 'Field',
+  Element: 'Element',
 };
 
-export interface FieldAssignment {
-  Id?: string | null;
-  TargetField: string;
-  Expr: Expr;
+export type RelationQueryOutputReferenceKind = 'Relation' | 'QueryResult';
+
+export const relationQueryOutputReferenceKinds = {
+  relation: 'Relation',
+  queryResult: 'QueryResult',
+} as const satisfies Record<string, RelationQueryOutputReferenceKind>;
+
+export const relationQueryOutputReferenceKindLabels: Record<RelationQueryOutputReferenceKind, string> = {
+  Relation: 'Relation',
+  QueryResult: 'QueryResult',
+};
+
+export interface RelationQueryRealizationTraceStep {
+  kind: RelationQueryRealizationTraceStepKind;
+  node: QueryNodeId;
+  siteKind?: RelationQueryExpressionSiteKind | null;
+  expressionSite?: ExprSiteId | null;
+  assignment?: QueryAssignmentId | null;
+  ordinal?: number | null;
+  invariantName?: string | null;
 }
 
-export type MappingScope = 0 | 1;
+export type RelationshipTraversalDirection = 'Forward' | 'Inverse';
 
-export const mappingScopes = {
-  rooted: 0,
-  set: 1,
-} as const satisfies Record<string, MappingScope>;
+export const relationshipTraversalDirections = {
+  forward: 'Forward',
+  inverse: 'Inverse',
+} as const satisfies Record<string, RelationshipTraversalDirection>;
 
-export const mappingScopeLabels: Record<MappingScope, string> = {
-  0: 'Rooted',
-  1: 'Set',
+export const relationshipTraversalDirectionLabels: Record<RelationshipTraversalDirection, string> = {
+  Forward: 'Forward',
+  Inverse: 'Inverse',
 };
 
-export type MappingDirection = 0 | 1 | 2;
+export type JoinKind = 'Inner' | 'Left' | 'Right' | 'Full';
 
-export const mappingDirections = {
-  sourceToTarget: 0,
-  targetToSource: 1,
-  bidirectional: 2,
-} as const satisfies Record<string, MappingDirection>;
+export const joinKinds = {
+  inner: 'Inner',
+  left: 'Left',
+  right: 'Right',
+  full: 'Full',
+} as const satisfies Record<string, JoinKind>;
 
-export const mappingDirectionLabels: Record<MappingDirection, string> = {
-  0: 'SourceToTarget',
-  1: 'TargetToSource',
-  2: 'Bidirectional',
+export const joinKindLabels: Record<JoinKind, string> = {
+  Inner: 'Inner',
+  Left: 'Left',
+  Right: 'Right',
+  Full: 'Full',
 };
 
-export interface NestedMapping {
-  Source: FieldPath;
-  Target: FieldPath;
-  NestedMappingId: MappingId;
+export type TemporalJoinMatch = {
+  readonly $temporalMatch: 'pointInInterval';
+} & TemporalPointInIntervalMatch | {
+  readonly $temporalMatch: 'intervalOverlap';
+} & TemporalIntervalOverlapMatch;
+
+export interface TemporalPointInIntervalMatch {
+  point: Expr;
+  interval: TemporalInterval;
 }
 
-export interface CollectionMapping {
-  SourceCollection: FieldPath;
-  TargetCollection: FieldPath;
-  ItemMappingId: MappingId;
+export interface TemporalIntervalOverlapMatch {
+  left: TemporalInterval;
+  right: TemporalInterval;
 }
 
-export interface MappingMetadata {
-  AllowCodegen: boolean;
-  Deterministic: boolean;
-  TransportMapping: boolean;
-  ExecutionPreference: MappingExecutionPreference;
-  Hints: ({
-    Key: string;
-    Value: string;
-  })[];
+export interface ProjectionAssignment {
+  id: QueryAssignmentId;
+  target: FieldPath;
+  value: Expr;
 }
 
-export type MaterializationStrategy = 0 | 1 | 2 | 3;
+export interface QueryGrouping {
+  id: QueryAssignmentId;
+  target: FieldPath;
+  key: Expr;
+}
+
+export interface QueryAggregateAssignment {
+  id: QueryAssignmentId;
+  target: FieldPath;
+  operation: AggregateOperator;
+  value?: Expr | null;
+  filter?: Expr | null;
+}
+
+export interface QueryOrdering {
+  key: Expr;
+  direction: QuerySortDirection;
+  nullPlacement: QueryNullPlacement;
+}
+
+export type QueryPageDefinition = {
+  readonly $page: 'offset';
+} & OffsetPageDefinition | {
+  readonly $page: 'keyset';
+} & KeysetPageDefinition;
 
-export const materializationStrategies = {
-  onDemand: 0,
-  asyncIndex: 1,
-  changeFeed: 2,
-  snapshot: 3,
-} as const satisfies Record<string, MaterializationStrategy>;
+export interface OffsetPageDefinition {
+  offset: number;
+  limit: number;
+}
 
-export const materializationStrategyLabels: Record<MaterializationStrategy, string> = {
-  0: 'OnDemand',
-  1: 'AsyncIndex',
-  2: 'ChangeFeed',
-  3: 'Snapshot',
+export interface KeysetPageDefinition {
+  after: Expr[];
+  limit: number;
+}
+
+export type QueryParameterId = string;
+
+export type FieldPresence = 'Required' | 'Optional';
+
+export const fieldPresences = {
+  required: 'Required',
+  optional: 'Optional',
+} as const satisfies Record<string, FieldPresence>;
+
+export const fieldPresenceLabels: Record<FieldPresence, string> = {
+  Required: 'Required',
+  Optional: 'Optional',
 };
 
-export type FreshnessPolicy = 0 | 1 | 2;
+export type QueryParameterDefaultKind = 'None' | 'Value';
 
-export const freshnessPolicies = {
-  strong: 0,
-  eventual: 1,
-  boundedStaleness: 2,
-} as const satisfies Record<string, FreshnessPolicy>;
+export const queryParameterDefaultKinds = {
+  none: 'None',
+  value: 'Value',
+} as const satisfies Record<string, QueryParameterDefaultKind>;
 
-export const freshnessPolicyLabels: Record<FreshnessPolicy, string> = {
-  0: 'Strong',
-  1: 'Eventual',
-  2: 'BoundedStaleness',
+export const queryParameterDefaultKindLabels: Record<QueryParameterDefaultKind, string> = {
+  None: 'None',
+  Value: 'Value',
 };
 
-export interface FieldPathSegment {
-  Kind: SegmentKind;
-  Segment?: string | null;
+export interface RelationDraftCandidate {
+  id: RelationDraftCandidateId;
+  value: Expr;
+}
+
+export type RelationDraftAssignmentResolution = {
+  readonly $resolution: 'selected';
+} & SelectedRelationDraftAssignmentResolution | {
+  readonly $resolution: 'omitted';
+} & OmittedRelationDraftAssignmentResolution | {
+  readonly $resolution: 'unresolved';
+} & UnresolvedRelationDraftAssignmentResolution | {
+  readonly $resolution: 'ambiguous';
+} & AmbiguousRelationDraftAssignmentResolution;
+
+export interface SelectedRelationDraftAssignmentResolution {
+  candidateId: RelationDraftCandidateId;
+}
+
+export type OmittedRelationDraftAssignmentResolution = Record<never, never>;
+
+export interface UnresolvedRelationDraftAssignmentResolution {
+  reasons: RelationDraftUnresolvedReason[];
 }
 
-export interface TypeId {
-  Value: string;
+export interface AmbiguousRelationDraftAssignmentResolution {
+  candidateIds: RelationDraftCandidateId[];
 }
 
-export type ScalarTypeKind = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+export type TypeId = string;
+
+export interface TypeInferenceDiagnostic {
+  reason: string;
+  message?: string | null;
+}
+
+export type ScalarTypeKind = 'Bool' | 'Int32' | 'Int64' | 'Decimal' | 'String' | 'Guid' | 'Date' | 'DateTime' | 'Instant' | 'Bytes';
 
 export const scalarTypeKinds = {
-  bool: 0,
-  int32: 1,
-  int64: 2,
-  decimal: 3,
-  string: 4,
-  guid: 5,
-  date: 6,
-  dateTime: 7,
-  instant: 8,
-  bytes: 9,
+  bool: 'Bool',
+  int32: 'Int32',
+  int64: 'Int64',
+  decimal: 'Decimal',
+  string: 'String',
+  guid: 'Guid',
+  date: 'Date',
+  dateTime: 'DateTime',
+  instant: 'Instant',
+  bytes: 'Bytes',
 } as const satisfies Record<string, ScalarTypeKind>;
 
 export const scalarTypeKindLabels: Record<ScalarTypeKind, string> = {
-  0: 'Bool',
-  1: 'Int32',
-  2: 'Int64',
-  3: 'Decimal',
-  4: 'String',
-  5: 'Guid',
-  6: 'Date',
-  7: 'DateTime',
-  8: 'Instant',
-  9: 'Bytes',
+  Bool: 'Bool',
+  Int32: 'Int32',
+  Int64: 'Int64',
+  Decimal: 'Decimal',
+  String: 'String',
+  Guid: 'Guid',
+  Date: 'Date',
+  DateTime: 'DateTime',
+  Instant: 'Instant',
+  Bytes: 'Bytes',
 };
 
-export type PrimitiveFormat = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+export type PrimitiveFormat = 'None' | 'Uuid' | 'IsoDate' | 'IsoDateTime' | 'IsoInstant' | 'CurrencyCode' | 'CountryCode' | 'Email' | 'Uri' | 'Base64';
 
 export const primitiveFormats = {
-  none: 0,
-  uuid: 1,
-  isoDate: 2,
-  isoDateTime: 3,
-  isoInstant: 4,
-  currencyCode: 5,
-  countryCode: 6,
-  email: 7,
-  uri: 8,
-  base64: 9,
+  none: 'None',
+  uuid: 'Uuid',
+  isoDate: 'IsoDate',
+  isoDateTime: 'IsoDateTime',
+  isoInstant: 'IsoInstant',
+  currencyCode: 'CurrencyCode',
+  countryCode: 'CountryCode',
+  email: 'Email',
+  uri: 'Uri',
+  base64: 'Base64',
 } as const satisfies Record<string, PrimitiveFormat>;
 
 export const primitiveFormatLabels: Record<PrimitiveFormat, string> = {
-  0: 'None',
-  1: 'Uuid',
-  2: 'IsoDate',
-  3: 'IsoDateTime',
-  4: 'IsoInstant',
-  5: 'CurrencyCode',
-  6: 'CountryCode',
-  7: 'Email',
-  8: 'Uri',
-  9: 'Base64',
+  None: 'None',
+  Uuid: 'Uuid',
+  IsoDate: 'IsoDate',
+  IsoDateTime: 'IsoDateTime',
+  IsoInstant: 'IsoInstant',
+  CurrencyCode: 'CurrencyCode',
+  CountryCode: 'CountryCode',
+  Email: 'Email',
+  Uri: 'Uri',
+  Base64: 'Base64',
 };
 
-export interface EntityTypeName {
-  Value: string;
-}
+export type EntityTypeName = string;
 
 export interface ObjectFieldTypeDef {
-  Name: string;
-  Type: TypeRef;
-  Presence: FieldPresence;
-  Annotations: ({
-    Key: AnnotationKey;
-    Value: AnnotationValue;
-  })[];
+  name: string;
+  type: TypeRef;
+  cardinality: FieldCardinality;
+  presence: FieldPresence;
+  nullability: FieldNullability;
+  annotations: Record<string, AnnotationValue>;
 }
 
-export type JsonTypeKind = 0 | 1 | 2 | 3 | 4 | 5;
+export type JsonTypeKind = 'Any' | 'Object' | 'Array' | 'String' | 'Number' | 'Boolean';
 
 export const jsonTypeKinds = {
-  any: 0,
-  object: 1,
-  array: 2,
-  string: 3,
-  number: 4,
-  boolean: 5,
+  any: 'Any',
+  object: 'Object',
+  array: 'Array',
+  string: 'String',
+  number: 'Number',
+  boolean: 'Boolean',
 } as const satisfies Record<string, JsonTypeKind>;
 
 export const jsonTypeKindLabels: Record<JsonTypeKind, string> = {
-  0: 'Any',
-  1: 'Object',
-  2: 'Array',
-  3: 'String',
-  4: 'Number',
-  5: 'Boolean',
+  Any: 'Any',
+  Object: 'Object',
+  Array: 'Array',
+  String: 'String',
+  Number: 'Number',
+  Boolean: 'Boolean',
 };
 
-export type MappingExecutionPreference = 0 | 1 | 2;
+export interface RelationQueryLogicalPlanInput {
+  canonicalInput: QueryNodeId;
+  effectiveInput: QueryNodeId;
+  bypasses: RelationQueryLogicalBypass[];
+}
+
+export type RelationQueryExplainRequirementInputKind = 'Field' | 'ObservationIdentity' | 'SourceSet' | 'Relationship' | 'Parameter' | 'Capability';
+
+export const relationQueryExplainRequirementInputKinds = {
+  field: 'Field',
+  observationIdentity: 'ObservationIdentity',
+  sourceSet: 'SourceSet',
+  relationship: 'Relationship',
+  parameter: 'Parameter',
+  capability: 'Capability',
+} as const satisfies Record<string, RelationQueryExplainRequirementInputKind>;
+
+export const relationQueryExplainRequirementInputKindLabels: Record<RelationQueryExplainRequirementInputKind, string> = {
+  Field: 'Field',
+  ObservationIdentity: 'ObservationIdentity',
+  SourceSet: 'SourceSet',
+  Relationship: 'Relationship',
+  Parameter: 'Parameter',
+  Capability: 'Capability',
+};
+
+export interface RelationQueryNativeCompilationDecisionReference {
+  requirement: RelationQueryRealizationRequirementId;
+  kind: CapabilityRealizationKind;
+  capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+  compositionRules: RelationQueryCompositionRuleId[];
+  override?: RelationQueryRealizationOverrideId | null;
+  operatingBoundaries: RelationQueryOperatingBoundaryId[];
+  preservedGuarantees: RelationQueryGuaranteeCapabilityKind[];
+}
 
-export const mappingExecutionPreferences = {
-  inMemory: 0,
-  materialized: 1,
-  codeGenerated: 2,
-} as const satisfies Record<string, MappingExecutionPreference>;
+export type RelationQueryRealizationTraceStepKind = 'Structural' | 'ExpressionSite' | 'AggregateOperation' | 'Terminal';
 
-export const mappingExecutionPreferenceLabels: Record<MappingExecutionPreference, string> = {
-  0: 'InMemory',
-  1: 'Materialized',
-  2: 'CodeGenerated',
+export const relationQueryRealizationTraceStepKinds = {
+  structural: 'Structural',
+  expressionSite: 'ExpressionSite',
+  aggregateOperation: 'AggregateOperation',
+  terminal: 'Terminal',
+} as const satisfies Record<string, RelationQueryRealizationTraceStepKind>;
+
+export const relationQueryRealizationTraceStepKindLabels: Record<RelationQueryRealizationTraceStepKind, string> = {
+  Structural: 'Structural',
+  ExpressionSite: 'ExpressionSite',
+  AggregateOperation: 'AggregateOperation',
+  Terminal: 'Terminal',
 };
 
-export type SegmentKind = 0 | 2;
+export type RelationQueryExpressionSiteKind = 'FilterPredicate' | 'JoinPredicate' | 'ExpandCollection' | 'ProjectionAssignmentValue' | 'DistinctKey' | 'AggregateGroupingKey' | 'AggregateAssignmentValue' | 'AggregateAssignmentFilter' | 'OrderKey' | 'KeysetBoundary' | 'RelationOutputKey' | 'RelationInvariant' | 'TemporalJoinCorrelation' | 'TemporalJoinPoint' | 'TemporalJoinIntervalLowerBound' | 'TemporalJoinIntervalUpperBound';
+
+export const relationQueryExpressionSiteKinds = {
+  filterPredicate: 'FilterPredicate',
+  joinPredicate: 'JoinPredicate',
+  expandCollection: 'ExpandCollection',
+  projectionAssignmentValue: 'ProjectionAssignmentValue',
+  distinctKey: 'DistinctKey',
+  aggregateGroupingKey: 'AggregateGroupingKey',
+  aggregateAssignmentValue: 'AggregateAssignmentValue',
+  aggregateAssignmentFilter: 'AggregateAssignmentFilter',
+  orderKey: 'OrderKey',
+  keysetBoundary: 'KeysetBoundary',
+  relationOutputKey: 'RelationOutputKey',
+  relationInvariant: 'RelationInvariant',
+  temporalJoinCorrelation: 'TemporalJoinCorrelation',
+  temporalJoinPoint: 'TemporalJoinPoint',
+  temporalJoinIntervalLowerBound: 'TemporalJoinIntervalLowerBound',
+  temporalJoinIntervalUpperBound: 'TemporalJoinIntervalUpperBound',
+} as const satisfies Record<string, RelationQueryExpressionSiteKind>;
+
+export const relationQueryExpressionSiteKindLabels: Record<RelationQueryExpressionSiteKind, string> = {
+  FilterPredicate: 'FilterPredicate',
+  JoinPredicate: 'JoinPredicate',
+  ExpandCollection: 'ExpandCollection',
+  ProjectionAssignmentValue: 'ProjectionAssignmentValue',
+  DistinctKey: 'DistinctKey',
+  AggregateGroupingKey: 'AggregateGroupingKey',
+  AggregateAssignmentValue: 'AggregateAssignmentValue',
+  AggregateAssignmentFilter: 'AggregateAssignmentFilter',
+  OrderKey: 'OrderKey',
+  KeysetBoundary: 'KeysetBoundary',
+  RelationOutputKey: 'RelationOutputKey',
+  RelationInvariant: 'RelationInvariant',
+  TemporalJoinCorrelation: 'TemporalJoinCorrelation',
+  TemporalJoinPoint: 'TemporalJoinPoint',
+  TemporalJoinIntervalLowerBound: 'TemporalJoinIntervalLowerBound',
+  TemporalJoinIntervalUpperBound: 'TemporalJoinIntervalUpperBound',
+};
 
-export const segmentKinds = {
-  field: 0,
-  element: 2,
-} as const satisfies Record<string, SegmentKind>;
+export type ExprSiteId = string;
 
-export const segmentKindLabels: Record<SegmentKind, string> = {
-  0: 'Field',
-  2: 'Element',
+export interface TemporalInterval {
+  lower: TemporalIntervalBound;
+  upper: TemporalIntervalBound;
+}
+
+export type QuerySortDirection = 'Ascending' | 'Descending';
+
+export const querySortDirections = {
+  ascending: 'Ascending',
+  descending: 'Descending',
+} as const satisfies Record<string, QuerySortDirection>;
+
+export const querySortDirectionLabels: Record<QuerySortDirection, string> = {
+  Ascending: 'Ascending',
+  Descending: 'Descending',
 };
 
-export type FieldPresence = 0 | 1;
+export type QueryNullPlacement = 'First' | 'Last';
 
-export const fieldPresences = {
-  required: 0,
-  optional: 1,
-} as const satisfies Record<string, FieldPresence>;
+export const queryNullPlacements = {
+  first: 'First',
+  last: 'Last',
+} as const satisfies Record<string, QueryNullPlacement>;
 
-export const fieldPresenceLabels: Record<FieldPresence, string> = {
-  0: 'Required',
-  1: 'Optional',
+export const queryNullPlacementLabels: Record<QueryNullPlacement, string> = {
+  First: 'First',
+  Last: 'Last',
+};
+
+export type RelationDraftUnresolvedReason = 'NoCandidate' | 'IncompatibleType' | 'UnsafeCardinality' | 'UnsafePresence' | 'UnsafeNullability' | 'ConversionRequired' | 'UnsupportedStructure' | 'UnsupportedTransformation' | 'MultipleCandidates';
+
+export const relationDraftUnresolvedReasons = {
+  noCandidate: 'NoCandidate',
+  incompatibleType: 'IncompatibleType',
+  unsafeCardinality: 'UnsafeCardinality',
+  unsafePresence: 'UnsafePresence',
+  unsafeNullability: 'UnsafeNullability',
+  conversionRequired: 'ConversionRequired',
+  unsupportedStructure: 'UnsupportedStructure',
+  unsupportedTransformation: 'UnsupportedTransformation',
+  multipleCandidates: 'MultipleCandidates',
+} as const satisfies Record<string, RelationDraftUnresolvedReason>;
+
+export const relationDraftUnresolvedReasonLabels: Record<RelationDraftUnresolvedReason, string> = {
+  NoCandidate: 'NoCandidate',
+  IncompatibleType: 'IncompatibleType',
+  UnsafeCardinality: 'UnsafeCardinality',
+  UnsafePresence: 'UnsafePresence',
+  UnsafeNullability: 'UnsafeNullability',
+  ConversionRequired: 'ConversionRequired',
+  UnsupportedStructure: 'UnsupportedStructure',
+  UnsupportedTransformation: 'UnsupportedTransformation',
+  MultipleCandidates: 'MultipleCandidates',
+};
+
+export type FieldCardinality = 'Single' | 'Many';
+
+export const fieldCardinalities = {
+  single: 'Single',
+  many: 'Many',
+} as const satisfies Record<string, FieldCardinality>;
+
+export const fieldCardinalityLabels: Record<FieldCardinality, string> = {
+  Single: 'Single',
+  Many: 'Many',
+};
+
+export type FieldNullability = 'NonNullable' | 'Nullable';
+
+export const fieldNullabilities = {
+  nonNullable: 'NonNullable',
+  nullable: 'Nullable',
+} as const satisfies Record<string, FieldNullability>;
+
+export const fieldNullabilityLabels: Record<FieldNullability, string> = {
+  NonNullable: 'NonNullable',
+  Nullable: 'Nullable',
 };
 
-export interface AnnotationKey {
-  Value: string;
+export interface RelationQueryLogicalBypass {
+  kind: RelationQueryLogicalBypassKind;
+  node: QueryNodeId;
+  relationship: RelationshipDefinition;
+  direction: RelationshipTraversalDirection;
+  cardinality: RelationshipTraversalCardinality;
+  from: ValueBindingId;
+  result: ValueBindingId;
 }
 
-export interface AnnotationValue {
-  Value?: unknown | null;
+export type CapabilityRealizationKind = 'Native' | 'Composed' | 'Constrained' | 'Override' | 'Unavailable' | 'Unknown';
+
+export const capabilityRealizationKinds = {
+  native: 'Native',
+  composed: 'Composed',
+  constrained: 'Constrained',
+  override: 'Override',
+  unavailable: 'Unavailable',
+  unknown: 'Unknown',
+} as const satisfies Record<string, CapabilityRealizationKind>;
+
+export const capabilityRealizationKindLabels: Record<CapabilityRealizationKind, string> = {
+  Native: 'Native',
+  Composed: 'Composed',
+  Constrained: 'Constrained',
+  Override: 'Override',
+  Unavailable: 'Unavailable',
+  Unknown: 'Unknown',
+};
+
+export type TemporalIntervalBound = {
+  readonly $temporalBound: 'unbounded';
+} & UnboundedTemporalIntervalBound | {
+  readonly $temporalBound: 'expression';
+} & ExpressionTemporalIntervalBound;
+
+export type UnboundedTemporalIntervalBound = Record<never, never>;
+
+export interface ExpressionTemporalIntervalBound {
+  value: Expr;
+  inclusion: TemporalBoundaryInclusion;
+  nullBehavior: TemporalNullBoundBehavior;
 }
 
+export type RelationQueryLogicalBypassKind = 'OptionalAtMostOneLeftRelationshipTraversal';
+
+export const relationQueryLogicalBypassKinds = {
+  optionalAtMostOneLeftRelationshipTraversal: 'OptionalAtMostOneLeftRelationshipTraversal',
+} as const satisfies Record<string, RelationQueryLogicalBypassKind>;
+
+export const relationQueryLogicalBypassKindLabels: Record<RelationQueryLogicalBypassKind, string> = {
+  OptionalAtMostOneLeftRelationshipTraversal: 'OptionalAtMostOneLeftRelationshipTraversal',
+};
+
+export type RelationshipTraversalCardinality = 'AtMostOne' | 'Many';
+
+export const relationshipTraversalCardinalities = {
+  atMostOne: 'AtMostOne',
+  many: 'Many',
+} as const satisfies Record<string, RelationshipTraversalCardinality>;
+
+export const relationshipTraversalCardinalityLabels: Record<RelationshipTraversalCardinality, string> = {
+  AtMostOne: 'AtMostOne',
+  Many: 'Many',
+};
+
+export type TemporalBoundaryInclusion = 'Inclusive' | 'Exclusive';
+
+export const temporalBoundaryInclusions = {
+  inclusive: 'Inclusive',
+  exclusive: 'Exclusive',
+} as const satisfies Record<string, TemporalBoundaryInclusion>;
+
+export const temporalBoundaryInclusionLabels: Record<TemporalBoundaryInclusion, string> = {
+  Inclusive: 'Inclusive',
+  Exclusive: 'Exclusive',
+};
+
+export type TemporalNullBoundBehavior = 'Invalid' | 'Unbounded';
+
+export const temporalNullBoundBehaviors = {
+  invalid: 'Invalid',
+  unbounded: 'Unbounded',
+} as const satisfies Record<string, TemporalNullBoundBehavior>;
+
+export const temporalNullBoundBehaviorLabels: Record<TemporalNullBoundBehavior, string> = {
+  Invalid: 'Invalid',
+  Unbounded: 'Unbounded',
+};
+
 export interface QualifiedShapeId {
-  GraphId: GraphId;
-  ShapeId: ShapeId;
+  graphId: GraphId;
+  shapeId: ShapeId;
 }
 
-export interface RelationDefinition {
-  Id: RelationId;
-  Name: RelationName;
-  Sources: RelationSource[];
-  Joins: JoinDefinition[];
-  Filter?: Expr | null;
-  BaseRowShapeId?: ShapeId | null;
-  Mappings: MappingDefinition[];
-  Materialization?: MaterializationSpec | null;
-  Metadata: RelationMetadata;
-  Invariants: InvariantDefinition[];
+export interface RelationQueryExplainArtifact {
+  schemaVersion: string;
+  stages: RelationQueryExplainStage[];
+  capabilitySummary?: RelationQueryCapabilitySummary | null;
+  diagnostics: RelationQueryExplainDiagnostic[];
+  fingerprint: RelationQueryExplainFingerprint;
+}
+
+export interface CompiledRelationQueryPhysicalPlan {
+  schemaVersion: string;
+  plan: RelationQueryCompiledPlanReference;
+  realization: RelationQueryRealizationFingerprint;
+  placement: RelationQuerySourcePlacement;
+  policy: RelationQueryPhysicalPlanningPolicy;
+  stages: RelationQueryPhysicalStage[];
+  evaluationOrder: RelationQueryPhysicalStageId[];
+  terminal: RelationQueryPhysicalStageId;
+  diagnostics: RelationQueryPhysicalPlanningDiagnostic[];
+  fingerprint: RelationQueryPhysicalPlanFingerprint;
+}
+
+export interface RelationQuerySourcePlacement {
+  schemaVersion: string;
+  plan: RelationQueryCompiledPlanReference;
+  conventionSetVersion: string;
+  sourceInstances: RelationQuerySourceInstance[];
+  bindings: RelationQuerySourcePlacementBinding[];
+  configurationDecisions: EffectiveConfigurationDecision[];
+  fingerprint: RelationQuerySourcePlacementFingerprint;
+}
+
+export interface RelationQueryBoundRealizationReport {
+  profileFeasibility: RelationQueryRealizationReport;
+  placement: RelationQuerySourcePlacementFingerprint;
+  branches: RelationQueryNativeResultBranchId[];
+  evidence: RelationQueryContextualEvidenceProjection;
+  diagnostics: RelationQueryRealizationDiagnostic[];
+  status: RelationQueryRealizationStatus;
+  fingerprint: RelationQueryBoundRealizationFingerprint;
+}
+
+export interface RelationQueryRealizationReport {
+  plan: RelationQueryCompiledPlanReference;
+  targetProfile: RelationQueryTargetCapabilityProfile;
+  policy: RelationQueryRealizationPolicy;
+  observability: RelationQueryResultObservability;
+  requirements: RelationQueryRealizationRequirement[];
+  decisions: RelationQueryRealizationDecision[];
+  diagnostics: RelationQueryRealizationDiagnostic[];
+  status: RelationQueryRealizationStatus;
+  fingerprint: RelationQueryRealizationFingerprint;
+}
+
+export interface RelationQueryTargetCapabilityProfile {
+  target: RelationQueryTargetId;
+  id: RelationQueryTargetProfileId;
+  supportedDefinitionSchemaVersions: string[];
+  supportedCompilerProfiles: string[];
+  capabilities: RelationQueryTargetCapabilityEvidence[];
+  operatingBoundaries: RelationQueryOperatingBoundary[];
+  description?: string | null;
+}
+
+export interface RelationDraftDocument {
+  schemaVersion: string;
+  draft: RelationDraft;
+  draftFingerprint: RelationDraftFingerprint;
+  metadata: RelationDraftDocumentMetadata;
+}
+
+export interface RelationQueryDocument {
+  schemaVersion: string;
+  definition: RelationQueryDefinition;
+  definitionFingerprint: RelationQueryDefinitionFingerprint;
+  metadata: RelationQueryDocumentMetadata;
+}
+
+export interface RelationshipCatalogDocument {
+  schemaVersion: string;
+  catalog: RelationshipCatalog;
+  catalogFingerprint: RelationshipCatalogFingerprint;
+  metadata: RelationshipCatalogDocumentMetadata;
 }