@kalada/host 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,562 @@
+import { KaladaV1Diagnostic, KaladaV1Program, CompiledKaladaV1Program, KaladaValue, KaladaV1Limits, KaladaV1FunctionLimits } from '@kalada/core';
+import { KaladaSyntaxDiagnostic, KaladaSyntaxStaticType, KaladaParseResult, KaladaSourceMapEntry, KaladaParseOptions } from '@kalada/syntax';
+
+type EditorGraphEdgeCategory = "root" | "definition" | "child" | "resolution";
+interface EditorGraphAdmissionRequest {
+    readonly maxEdges: number;
+    readonly definitions: number;
+    readonly children: number;
+    readonly resolutions: number;
+    readonly roots: number;
+    readonly evidenceReserve?: number;
+}
+interface EditorGraphAdmission {
+    readonly model: Readonly<{
+        readonly B: number;
+        readonly D: number;
+        readonly C: number;
+        readonly V: number;
+        readonly R: number;
+        readonly Q: number;
+    }>;
+    readonly requestedChildren: number;
+    readonly backboneAdmitted: boolean;
+    readonly truncated: boolean;
+    readonly total: number;
+    readonly remaining: number;
+}
+interface EditorGraphEdgeUsage {
+    readonly budget: number;
+    readonly root: number;
+    readonly definition: number;
+    readonly child: number;
+    readonly resolution: number;
+    readonly total: number;
+    readonly remaining: number;
+}
+interface EditorGraphEdgeMeter {
+    readonly claim: (category: EditorGraphEdgeCategory) => boolean;
+    readonly snapshot: () => EditorGraphEdgeUsage;
+}
+declare function calculateEditorGraphAdmission(request: EditorGraphAdmissionRequest): EditorGraphAdmission;
+declare function createEditorGraphEdgeMeter(maxEdges: number): EditorGraphEdgeMeter;
+
+type HostPath = readonly (string | number)[];
+type EditorData = null | boolean | number | string | readonly EditorData[] | {
+    readonly [key: string]: EditorData;
+};
+interface EditorRelationShape {
+    readonly name: string;
+    readonly key?: string;
+    readonly shape: EditorShape;
+}
+interface EditorShapeEvidence {
+    readonly sourceId?: string;
+    readonly annotations?: EditorData;
+    readonly constraints?: EditorData;
+    readonly relations?: readonly EditorRelationShape[];
+}
+type EditorUnknownCode = "invalid-shape" | "unsupported-shape" | "depth-limit" | "node-limit" | "edge-limit" | "unresolved-reference";
+interface EditorUnknownEvidence {
+    readonly code: EditorUnknownCode;
+    readonly path: HostPath;
+}
+type EditorScalarName = "null" | "boolean" | "number" | "integer" | "string" | "undefined" | "void" | "bigint" | "symbol" | "date" | "NaN" | "json" | "instant" | "duration";
+interface EditorScalarShape extends EditorShapeEvidence {
+    readonly kind: "scalar";
+    readonly name: EditorScalarName;
+}
+interface EditorUnknownShape extends EditorShapeEvidence {
+    readonly kind: "unknown";
+    readonly reason?: string;
+    readonly evidenceCode?: EditorUnknownCode;
+}
+interface EditorObjectPropertyShape {
+    readonly name: string;
+    readonly required: boolean;
+    readonly presence?: "required" | "optional" | "unknown";
+    readonly shape: EditorShape;
+}
+interface EditorObjectShape extends EditorShapeEvidence {
+    readonly kind: "object";
+    readonly properties: readonly EditorObjectPropertyShape[];
+    readonly requiredNames?: readonly string[];
+    readonly additionalProperties?: EditorShape;
+    readonly unknownKeys?: "strip" | "reject" | "passthrough" | "schema" | "unknown";
+}
+interface EditorArrayShape extends EditorShapeEvidence {
+    readonly kind: "array";
+    readonly element: EditorShape;
+}
+interface EditorTupleShape extends EditorShapeEvidence {
+    readonly kind: "tuple";
+    readonly items: readonly EditorShape[];
+    readonly rest?: EditorShape;
+}
+interface EditorUnionShape extends EditorShapeEvidence {
+    readonly kind: "union";
+    readonly variants: readonly EditorShape[];
+    readonly semantics?: string;
+    readonly discriminator?: EditorData;
+}
+interface EditorReferenceShape extends EditorShapeEvidence {
+    readonly kind: "reference";
+    readonly definition: string;
+    readonly reference?: string;
+    readonly unresolved?: string;
+}
+interface EditorLiteralShape extends EditorShapeEvidence {
+    readonly kind: "literal";
+    readonly value: EditorData;
+}
+interface EditorEnumShape extends EditorShapeEvidence {
+    readonly kind: "enum";
+    readonly values: readonly EditorData[];
+}
+interface EditorNeverShape extends EditorShapeEvidence {
+    readonly kind: "never";
+}
+interface EditorUnconstrainedShape extends EditorShapeEvidence {
+    readonly kind: "unconstrained";
+    readonly domain: "json" | "js";
+}
+interface EditorOpaqueShape extends EditorShapeEvidence {
+    readonly kind: "opaque";
+    readonly reason: string;
+}
+interface EditorRecordShape extends EditorShapeEvidence {
+    readonly kind: "record";
+    readonly key: EditorShape;
+    readonly value: EditorShape;
+    readonly exhaustive: boolean | "unknown";
+}
+interface EditorIntersectionShape extends EditorShapeEvidence {
+    readonly kind: "intersection";
+    readonly operands: readonly EditorShape[];
+}
+interface EditorWrapperShape extends EditorShapeEvidence {
+    readonly kind: "wrapper";
+    readonly wrapper: string;
+    readonly inner: EditorShape;
+    readonly value?: EditorData;
+}
+type EditorShape = EditorScalarShape | EditorUnknownShape | EditorObjectShape | EditorArrayShape | EditorTupleShape | EditorUnionShape | EditorReferenceShape | EditorLiteralShape | EditorEnumShape | EditorNeverShape | EditorUnconstrainedShape | EditorOpaqueShape | EditorRecordShape | EditorIntersectionShape | EditorWrapperShape;
+interface ManualEditorDefinition {
+    readonly name: string;
+    readonly shape: EditorShape;
+}
+interface ManualEditorShapeDocument {
+    readonly root: EditorShape;
+    readonly definitions?: readonly ManualEditorDefinition[];
+    readonly evidence?: readonly EditorUnknownCode[];
+}
+interface EditorGraphLimits {
+    readonly maxDepth: number;
+    readonly maxNodes: number;
+    readonly maxEdges: number;
+}
+interface EditorGraphInput {
+    readonly bindingId: string;
+    readonly path: HostPath;
+    readonly document: ManualEditorShapeDocument;
+}
+interface EditorEdge {
+    readonly nodeId: string;
+    readonly path: HostPath;
+    readonly cycle: boolean;
+}
+interface EditorPropertyEdge extends EditorEdge {
+    readonly name: string;
+    readonly required: boolean;
+    readonly presence?: "required" | "optional" | "unknown";
+}
+interface EditorRelationEdge extends EditorEdge {
+    readonly name: string;
+    readonly key?: string;
+}
+interface EditorNodeBase {
+    readonly id: string;
+    readonly path: HostPath;
+    readonly availability: "available" | "unavailable" | "unknown";
+    readonly evidence: readonly EditorUnknownEvidence[];
+    readonly sourceId?: string;
+    readonly annotations?: EditorData;
+    readonly constraints?: EditorData;
+    readonly relations?: readonly EditorRelationEdge[];
+}
+interface EditorScalarNode extends EditorNodeBase {
+    readonly kind: "scalar";
+    readonly name: EditorScalarName;
+}
+interface EditorUnknownNode extends EditorNodeBase {
+    readonly kind: "unknown";
+    readonly reason?: string;
+}
+interface EditorObjectNode extends EditorNodeBase {
+    readonly kind: "object";
+    readonly properties: readonly EditorPropertyEdge[];
+    readonly requiredNames?: readonly string[];
+    readonly unknownKeys?: "strip" | "reject" | "passthrough" | "schema" | "unknown";
+    readonly additionalProperties?: EditorEdge;
+}
+interface EditorArrayNode extends EditorNodeBase {
+    readonly kind: "array";
+    readonly element: EditorEdge;
+}
+interface EditorTupleNode extends EditorNodeBase {
+    readonly kind: "tuple";
+    readonly items: readonly EditorEdge[];
+    readonly rest?: EditorEdge;
+}
+interface EditorUnionNode extends EditorNodeBase {
+    readonly kind: "union";
+    readonly variants: readonly EditorEdge[];
+    readonly semantics?: string;
+    readonly discriminator?: EditorData;
+}
+interface EditorReferenceNode extends EditorNodeBase {
+    readonly kind: "reference";
+    readonly definition: string;
+    readonly status: "resolved" | "unresolved";
+    readonly target?: EditorEdge;
+    readonly reference?: string;
+    readonly unresolved?: string;
+}
+interface EditorLiteralNode extends EditorNodeBase {
+    readonly kind: "literal";
+    readonly value: EditorData;
+}
+interface EditorEnumNode extends EditorNodeBase {
+    readonly kind: "enum";
+    readonly values: readonly EditorData[];
+}
+interface EditorNeverNode extends EditorNodeBase {
+    readonly kind: "never";
+}
+interface EditorUnconstrainedNode extends EditorNodeBase {
+    readonly kind: "unconstrained";
+    readonly domain: "json" | "js";
+}
+interface EditorOpaqueNode extends EditorNodeBase {
+    readonly kind: "opaque";
+    readonly reason: string;
+}
+interface EditorRecordNode extends EditorNodeBase {
+    readonly kind: "record";
+    readonly key: EditorEdge;
+    readonly value: EditorEdge;
+    readonly exhaustive: boolean | "unknown";
+}
+interface EditorIntersectionNode extends EditorNodeBase {
+    readonly kind: "intersection";
+    readonly operands: readonly EditorEdge[];
+}
+interface EditorWrapperNode extends EditorNodeBase {
+    readonly kind: "wrapper";
+    readonly wrapper: string;
+    readonly inner: EditorEdge;
+    readonly value?: EditorData;
+}
+type EditorNode = EditorScalarNode | EditorUnknownNode | EditorObjectNode | EditorArrayNode | EditorTupleNode | EditorUnionNode | EditorReferenceNode | EditorLiteralNode | EditorEnumNode | EditorNeverNode | EditorUnconstrainedNode | EditorOpaqueNode | EditorRecordNode | EditorIntersectionNode | EditorWrapperNode;
+interface EditorGraphRoot extends EditorEdge {
+    readonly bindingId: string;
+}
+interface EditorGraphDefinition {
+    readonly bindingId: string;
+    readonly name: string;
+    readonly nodeId: string;
+    readonly path: HostPath;
+}
+interface EditorGraph {
+    readonly format: "kalada-editor-graph-v1";
+    readonly nodeIdScope: "document-local";
+    readonly limits: EditorGraphLimits;
+    readonly roots: readonly EditorGraphRoot[];
+    readonly nodes: readonly EditorNode[];
+    readonly definitions: readonly EditorGraphDefinition[];
+    readonly evidence: readonly EditorUnknownEvidence[];
+    readonly admission?: EditorGraphEdgeUsage;
+}
+interface EditorTraversalOptions {
+    readonly maxDepth?: number;
+    readonly maxVisits?: number;
+}
+interface EditorTraversalStep {
+    readonly nodeId: string;
+    readonly path: HostPath;
+    readonly depth: number;
+    readonly via: "root" | "property" | "additional-property" | "element" | "item" | "rest" | "variant" | "operand" | "record-key" | "record-value" | "wrapper" | "relation" | "reference";
+    readonly cycle: boolean;
+    readonly availability: "available" | "unavailable" | "unknown";
+}
+
+type SerializablePrimitive = null | boolean | number | string;
+type SerializableValue = SerializablePrimitive | readonly SerializableValue[] | {
+    readonly [key: string]: SerializableValue;
+};
+type CapabilityMode = "sync" | "async";
+type CapabilityKind = "validator" | "codec";
+interface ProviderIdentityInput {
+    readonly providerId?: string;
+    readonly providerVersion?: string;
+    readonly configurationDigest?: string;
+    readonly cacheable?: boolean;
+}
+interface CapabilityIdentityInput {
+    readonly capabilityId?: string;
+    readonly capabilityVersion?: string;
+    readonly configurationDigest?: string;
+    readonly cacheable?: boolean;
+}
+type Cacheability = Readonly<{
+    cacheable: true;
+    id: string;
+    version: string;
+    configurationDigest: string;
+}> | Readonly<{
+    cacheable: false;
+    reason: "explicitly-disabled" | "missing-identity" | "provider-not-cacheable" | "capability-not-cacheable";
+}>;
+interface ManualValidatorCapability extends CapabilityIdentityInput {
+    readonly handle: string;
+    readonly kind: "validator";
+    readonly mode: CapabilityMode;
+    readonly decode: (value: unknown) => unknown;
+}
+interface ManualCodecCapability extends CapabilityIdentityInput {
+    readonly handle: string;
+    readonly kind: "codec";
+    readonly mode: CapabilityMode;
+    readonly convert: (value: unknown) => unknown;
+}
+type ManualCapability = ManualValidatorCapability | ManualCodecCapability;
+interface CapabilityDeclaration {
+    readonly handle: string;
+    readonly kind: CapabilityKind;
+    readonly mode: CapabilityMode;
+    readonly capabilityId?: string;
+    readonly capabilityVersion?: string;
+    readonly configurationDigest?: string;
+    readonly identity: Cacheability;
+}
+type LiveCapability = Readonly<CapabilityDeclaration & {
+    readonly kind: "validator";
+    readonly decode: (value: unknown) => unknown;
+}> | Readonly<CapabilityDeclaration & {
+    readonly kind: "codec";
+    readonly convert: (value: unknown) => unknown;
+}>;
+interface CapabilitySnapshot {
+    readonly scope: "instance";
+    readonly capabilities: Readonly<Record<string, LiveCapability>>;
+}
+interface ProvenanceEntry {
+    readonly providerId: string;
+    readonly providerVersion?: string;
+    readonly source?: string;
+    readonly extractor?: string;
+    readonly override?: string;
+}
+interface ManualBindingDescriptor {
+    readonly id: string;
+    readonly name: string;
+    readonly path: readonly string[];
+    readonly semanticType: KaladaSyntaxStaticType;
+    readonly editorShape?: ManualEditorShapeDocument;
+    readonly validatorHandle?: string;
+    readonly codecHandle?: string;
+    readonly metadata?: SerializableValue;
+    readonly provenance?: readonly ProvenanceEntry[];
+}
+interface ManualProviderInput extends ProviderIdentityInput {
+    readonly mode: CapabilityMode;
+    readonly bindings: readonly ManualBindingDescriptor[];
+    readonly capabilities?: readonly ManualCapability[];
+}
+interface NormalizedBinding {
+    readonly id: string;
+    readonly name: string;
+    readonly path: readonly string[];
+    readonly semanticType: KaladaSyntaxStaticType;
+    readonly editorShapeRoot?: string;
+    readonly validator?: CapabilityDeclaration;
+    readonly codec?: CapabilityDeclaration;
+    readonly metadata?: SerializableValue;
+    readonly provenance: readonly ProvenanceEntry[];
+}
+interface HostCompileBinding {
+    readonly id: string;
+    readonly name: string;
+    readonly semanticType: KaladaSyntaxStaticType;
+}
+interface HostCompileProjection {
+    readonly format: "kalada-host-compile-projection-v1";
+    readonly bindings: readonly HostCompileBinding[];
+}
+interface NormalizedEnvironment {
+    readonly format: "kalada-host-environment-v1";
+    readonly provider: Readonly<{
+        mode: CapabilityMode;
+        providerId?: string;
+        providerVersion?: string;
+        configurationDigest?: string;
+        identity: Cacheability;
+    }>;
+    readonly cacheability: Cacheability;
+    readonly compileProjection: HostCompileProjection;
+    readonly bindings: readonly NormalizedBinding[];
+    readonly capabilities: readonly CapabilityDeclaration[];
+    readonly editorGraph: EditorGraph;
+}
+type HostEnvironmentDiagnosticCode = "HOST_ENVIRONMENT_INVALID_PROVIDER" | "HOST_ENVIRONMENT_INVALID_IDENTITY" | "HOST_ENVIRONMENT_INVALID_CAPABILITY" | "HOST_ENVIRONMENT_DUPLICATE_CAPABILITY" | "HOST_ENVIRONMENT_INVALID_BINDING" | "HOST_ENVIRONMENT_DUPLICATE_BINDING" | "HOST_ENVIRONMENT_INVALID_SEMANTIC_TYPE" | "HOST_ENVIRONMENT_INVALID_METADATA" | "HOST_ENVIRONMENT_INVALID_PROVENANCE" | "HOST_ENVIRONMENT_UNKNOWN_CAPABILITY";
+type HostDiagnosticPhase = "environment" | "parse" | "lower" | "compile" | "link" | "bind" | "evaluate";
+interface Utf16Position {
+    readonly line: number;
+    readonly character: number;
+}
+interface Utf16Range {
+    readonly start: Utf16Position;
+    readonly end: Utf16Position;
+}
+interface HostDiagnosticSource {
+    readonly uri: string;
+    readonly range: Utf16Range;
+}
+type HostDiagnosticCause = Readonly<KaladaSyntaxDiagnostic | KaladaV1Diagnostic>;
+interface HostDiagnostic {
+    readonly code: string;
+    readonly phase: HostDiagnosticPhase;
+    readonly message: string;
+    readonly source?: HostDiagnosticSource;
+    readonly bindingPath?: HostPath;
+    readonly provenance?: Readonly<Record<string, string>>;
+    readonly cause?: HostDiagnosticCause;
+}
+interface HostEnvironmentDiagnostic extends HostDiagnostic {
+    readonly code: HostEnvironmentDiagnosticCode;
+    readonly phase: "environment";
+}
+type DescribeEnvironmentResult = Readonly<{
+    ok: true;
+    environment: NormalizedEnvironment;
+    capabilitySnapshot: CapabilitySnapshot;
+}> | Readonly<{
+    ok: false;
+    diagnostics: readonly HostEnvironmentDiagnostic[];
+}>;
+interface ManualProvider {
+    readonly kind: "manual";
+    readonly describe: () => DescribeEnvironmentResult;
+}
+
+type HostExecutionDiagnosticCode = "HOST_PARSE_INVALID_SOURCE" | "HOST_COMPILE_INVALID_OPTIONS" | "HOST_COMPILE_INVALID_PROJECTION" | "HOST_LINK_INCOMPATIBLE_ENVIRONMENT" | "HOST_LINK_MISSING_BINDING" | "HOST_LINK_INVALID_CAPABILITY" | "HOST_LINK_ASYNC_UNSUPPORTED" | "HOST_BINDING_MISSING" | "HOST_BINDING_DECODE" | "HOST_BINDING_CONVERSION" | "HOST_BINDING_SEMANTIC";
+type HostResult<T> = Readonly<{
+    ok: true;
+    value: T;
+}> | Readonly<{
+    ok: false;
+    diagnostics: readonly HostDiagnostic[];
+}>;
+interface HostExpressionSource {
+    readonly uri: string;
+    readonly text: string;
+}
+interface HostParseOptions {
+    readonly sourceUri?: string;
+    readonly syntax?: KaladaParseOptions;
+}
+interface HostCompileOptions {
+    readonly profile?: string;
+    readonly limits?: Partial<KaladaV1Limits & KaladaV1FunctionLimits>;
+}
+interface HostPrepareOptions {
+    readonly parse?: HostParseOptions;
+    readonly compile?: HostCompileOptions;
+}
+interface ParsedExpression {
+    readonly format: "kalada-host-parsed-expression-v1";
+    readonly source: HostExpressionSource;
+    readonly syntax: KaladaParseResult;
+    readonly parseFingerprintInput: Readonly<Record<string, unknown>>;
+}
+interface CompiledExpression {
+    readonly format: "kalada-host-compiled-expression-v1";
+    readonly source: HostExpressionSource;
+    readonly parsed: ParsedExpression;
+    readonly program: KaladaV1Program<string>;
+    readonly sourceMap: readonly KaladaSourceMapEntry[];
+    readonly coreCompilation: CompiledKaladaV1Program<string>;
+    readonly dependencies: readonly string[];
+    readonly resultType: KaladaSyntaxStaticType;
+    readonly compileProjectionFingerprint: string;
+    readonly compileFingerprint: string;
+}
+interface HostLinkPlanSlot {
+    readonly index: number;
+    readonly bindingId: string;
+    readonly name: string;
+    readonly path: HostPath;
+    readonly semanticType: KaladaSyntaxStaticType;
+    readonly validator?: CapabilityDeclaration;
+    readonly codec?: CapabilityDeclaration;
+}
+interface PreparedExpression {
+    readonly format: "kalada-host-prepared-expression-v1";
+    readonly compiled: CompiledExpression;
+    readonly environment: NormalizedEnvironment;
+    readonly linkPlan: readonly HostLinkPlanSlot[];
+    readonly linkFingerprint?: string;
+    evaluate(values: unknown): HostResult<KaladaValue>;
+}
+type LinkExpressionResult = HostResult<PreparedExpression>;
+type CompileExpressionResult = HostResult<CompiledExpression>;
+type ParseExpressionResult = HostResult<ParsedExpression>;
+type PrepareExpressionResult = HostResult<PreparedExpression>;
+type EvaluateExpressionResult = HostResult<KaladaValue>;
+
+declare function parseExpression(source: string, options?: HostParseOptions): ParseExpressionResult;
+declare function compileExpression(parsed: ParsedExpression, projection: HostCompileProjection, options?: HostCompileOptions): CompileExpressionResult;
+
+declare const DEFAULT_EDITOR_GRAPH_LIMITS: EditorGraphLimits;
+declare function createEditorGraph(inputs: readonly EditorGraphInput[], requestedLimits?: Partial<EditorGraphLimits>): EditorGraph;
+
+declare function traverseEditorGraph(graph: EditorGraph, options?: EditorTraversalOptions): readonly EditorTraversalStep[];
+
+declare function prepareExpression(source: string, provider: ManualProvider, options?: HostPrepareOptions): PrepareExpressionResult;
+declare function evaluateExpression(source: string, provider: ManualProvider, values: unknown, options?: HostPrepareOptions): EvaluateExpressionResult;
+
+declare const HOST_COMPILE_FINGERPRINT_VERSION = "kalada-host-compile-fingerprint-v1";
+declare const HOST_LINK_FINGERPRINT_VERSION = "kalada-host-link-fingerprint-v1";
+
+declare function linkExpression(compiled: CompiledExpression, environment: NormalizedEnvironment, snapshot: CapabilitySnapshot): LinkExpressionResult;
+
+declare function createManualProvider(input: ManualProviderInput): ManualProvider;
+declare function describeEnvironment(provider: ManualProvider): DescribeEnvironmentResult;
+declare function normalizeManualEnvironment(input: ManualProviderInput): DescribeEnvironmentResult;
+
+type SemanticTypeResult = Readonly<{
+    ok: true;
+    value: KaladaSyntaxStaticType;
+}> | Readonly<{
+    ok: false;
+}>;
+declare function readSemanticType(input: unknown): SemanticTypeResult;
+
+interface SerializableLimits {
+    readonly maxDepth: number;
+    readonly maxNodes: number;
+    readonly maxCollectionSize: number;
+    readonly maxStringLength: number;
+}
+declare const DEFAULT_SERIALIZABLE_LIMITS: SerializableLimits;
+type SerializableCloneResult = Readonly<{
+    ok: true;
+    value: SerializableValue;
+}> | Readonly<{
+    ok: false;
+    reason: "invalid-value" | "accessor" | "cycle" | "depth-limit" | "size-limit";
+    path: HostPath;
+}>;
+declare function cloneSerializableData(input: unknown, limits?: SerializableLimits): SerializableCloneResult;
+
+export { type Cacheability, type CapabilityDeclaration, type CapabilityIdentityInput, type CapabilityKind, type CapabilityMode, type CapabilitySnapshot, type CompileExpressionResult, type CompiledExpression, DEFAULT_EDITOR_GRAPH_LIMITS, DEFAULT_SERIALIZABLE_LIMITS, type DescribeEnvironmentResult, type EditorArrayNode, type EditorArrayShape, type EditorData, type EditorEdge, type EditorEnumNode, type EditorEnumShape, type EditorGraph, type EditorGraphAdmission, type EditorGraphAdmissionRequest, type EditorGraphDefinition, type EditorGraphEdgeCategory, type EditorGraphEdgeMeter, type EditorGraphEdgeUsage, type EditorGraphInput, type EditorGraphLimits, type EditorGraphRoot, type EditorIntersectionNode, type EditorIntersectionShape, type EditorLiteralNode, type EditorLiteralShape, type EditorNeverNode, type EditorNeverShape, type EditorNode, type EditorObjectNode, type EditorObjectPropertyShape, type EditorObjectShape, type EditorOpaqueNode, type EditorOpaqueShape, type EditorPropertyEdge, type EditorRecordNode, type EditorRecordShape, type EditorReferenceNode, type EditorReferenceShape, type EditorRelationEdge, type EditorRelationShape, type EditorScalarName, type EditorScalarNode, type EditorScalarShape, type EditorShape, type EditorTraversalOptions, type EditorTraversalStep, type EditorTupleNode, type EditorTupleShape, type EditorUnconstrainedNode, type EditorUnconstrainedShape, type EditorUnionNode, type EditorUnionShape, type EditorUnknownCode, type EditorUnknownEvidence, type EditorUnknownNode, type EditorUnknownShape, type EditorWrapperNode, type EditorWrapperShape, type EvaluateExpressionResult, HOST_COMPILE_FINGERPRINT_VERSION, HOST_LINK_FINGERPRINT_VERSION, type HostCompileBinding, type HostCompileOptions, type HostCompileProjection, type HostDiagnostic, type HostDiagnosticCause, type HostDiagnosticPhase, type HostDiagnosticSource, type HostEnvironmentDiagnostic, type HostEnvironmentDiagnosticCode, type HostExecutionDiagnosticCode, type HostExpressionSource, type HostLinkPlanSlot, type HostParseOptions, type HostPath, type HostPrepareOptions, type HostResult, type LinkExpressionResult, type LiveCapability, type ManualBindingDescriptor, type ManualCapability, type ManualCodecCapability, type ManualEditorDefinition, type ManualEditorShapeDocument, type ManualProvider, type ManualProviderInput, type ManualValidatorCapability, type NormalizedBinding, type NormalizedEnvironment, type ParseExpressionResult, type ParsedExpression, type PrepareExpressionResult, type PreparedExpression, type ProvenanceEntry, type ProviderIdentityInput, type SemanticTypeResult, type SerializableCloneResult, type SerializableLimits, type SerializablePrimitive, type SerializableValue, type Utf16Position, type Utf16Range, calculateEditorGraphAdmission, cloneSerializableData, compileExpression, createEditorGraph, createEditorGraphEdgeMeter, createManualProvider, describeEnvironment, evaluateExpression, linkExpression, normalizeManualEnvironment, parseExpression, prepareExpression, readSemanticType, traverseEditorGraph };