Classes
Interfaces
References
ExecutionConfiguration
Re-exports ExecutionConfigurationResultOwner
Re-exports ResultOwnerResultAdapter
Re-exports ResultAdapterResultRetention
Re-exports ResultRetentionResultOwnerPageRequest
Re-exports ResultOwnerPageRequestResultOwnerPage
Re-exports ResultOwnerPageComputationBasis
Re-exports ComputationBasisBasisRequirements
Re-exports BasisRequirementsBasisAssessment
Re-exports BasisAssessmentResultClaim
Re-exports ResultClaimPreparationRef
Re-exports PreparationRefCustodyOutcome
Re-exports CustodyOutcomeResultReader
Re-exports ResultReaderResults
Re-exports ResultsResultPage
Re-exports ResultPageRetentionDemand
Re-exports RetentionDemandExecutionProviderOutcome
Re-exports ExecutionProviderOutcomeComputationBinding
Re-exports ComputationBindingComputationSpecification
Re-exports ComputationSpecificationComputationEvaluation
Re-exports ComputationEvaluationComputationCallRecord
Re-exports ComputationCallRecordExecutionProvider
Re-exports ExecutionProviderExecutionProviderRequest
Re-exports ExecutionProviderRequestExecutionReconciliationRequest
Re-exports ExecutionReconciliationRequestExecutionTermination
Re-exports ExecutionTerminationComputationSampling
Re-exports ComputationSamplingComputationInvocation
Re-exports ComputationInvocationreadResultFile
Re-exports readResultFilevalueRow
Re-exports valueRowType Aliases
ScenarioHeldCall
Ƭ ScenarioHeldCall:Object
Not exported: an exported type refers to it.
Type declaration
ComputationAddress
Ƭ ComputationAddress:string & { __computationAddress: unique symbol }
A definition address in the selected application/component program.
ComputationPreparationRequest
Ƭ ComputationPreparationRequest:Object
Inert recovery input for the original native Run admission. The server
captures state, plans and admits through its existing owners in one call.
Type declaration
ComputationPreparationCapture
Ƭ ComputationPreparationCapture:Object
Type declaration
CapabilityEvidenceReference
Ƭ CapabilityEvidenceReference:Object
Type declaration
CapabilityObservation
Ƭ CapabilityObservation<T>: { state: "observed" ; value: T ; observed_at: number ; evidence: CapabilityEvidenceReference[] } | { state: "unknown" | "unavailable" | "unsupported" ; reason: { code: string ; message: string } }
Type parameters
CapabilityInspection
Ƭ CapabilityInspection<Contract, Installed, Observation, Qualification>: Object
Independent projections from installed owners. Configuration, a current
provider observation and a qualification receipt establish different facts.
Type parameters
Type declaration
RelationalSource
Ƭ RelationalSource<Row>: Readonly<{ dataset: string ; contract: string ; __row?: Row }>
Logical row contract; no storage, connection or execution authority.
Type parameters
PortSource
Ƭ PortSource:RelationalSource | Readonly<{ type: ComputationType }>
ValuePortType
Ƭ ValuePortType:Extract<ComputationType, { kind: "value" }>
Not exported: an exported type refers to it.
CapturedValue
Ƭ CapturedValue:Readonly<{ type: ValuePortType ; [capturedValue]: true }>
An authoring reference, never an in-memory raster or a storage handle.
Column
Ƭ Column:TransformationColumn
A relational column: the SDK’s C1 column model.
EngineName
Ƭ EngineName:"python" | "spark" | "snowflake" | "databricks" | "bigquery"
Engine
Ƭ Engine:Readonly<{ engine: EngineName ; connection: string | null }>
Where a region runs. connection names the customer connection a
coordinating worker holds for a warehouse; Spark uses the pipeline’s
execution resource and no connection.
Ref
Ƭ Ref: {input: string } | { node: string ; port?: string }
ProjectTransformHandler
Ƭ ProjectTransformHandler:Object
Type declaration
TransformABI
Ƭ TransformABI:"spark-dataframe/v3" | "sql-table/v2" | "snowpark-project/v2" | "databricks-project/v2"
TransformHandler
Ƭ TransformHandler:ProjectTransformHandler | { kind: "python" ; entrypoint: string ; revision: string ; manifest: string }
TransformArgumentScope
Ƭ TransformArgumentScope:Object
An opaque handler has its own lexical scalar contract. Bindings are
expressions in its enclosing program, evaluated by the semantic kernel.
Type declaration
LogicalNode
Ƭ LogicalNode: {id: string ; kind: "value_row" ; from: Ref ; field: string ; columns: Column[] } | { id: string ; kind: "raster" ; operation: RasterOperation ; inputs: Ref[] ; type: ComputationType } | { id: string ; kind: "relation" ; expression: RelationExpression ; sources: Record<string, Ref> ; columns: Column[] ; placement?: Engine } | { id: string ; kind: "transform" ; engine: EngineName ; abi: TransformABI ; connection?: string ; handler: TransformHandler ; replay: "deterministic" | "none" ; argument_scope: TransformArgumentScope ; inputs: Record<string, Ref> ; outputs: Record<string, Column[]> } | { id: string ; kind: "checkpoint" ; key: string ; from: Ref ; columns: Column[] ; retention: "evaluation" ; storage: string | null } | { id: string ; kind: "transfer" ; from: Ref ; columns: Column[] ; to: Engine ; transport: TransferTransport ; max_payload_bytes: string }
LogicalProgram
Ƭ LogicalProgram:Object
Type declaration
TransformPreparation
Ƭ TransformPreparation:Object
Where preparation renders a transformation’s generated Python contracts.
Development paths, never part of any revision.
Type declaration
CapturedStage
Ƭ CapturedStage:Object
A named intermediate relation, recorded outside every revision: renaming
or adding a stage never changes the logical program. node is the logical
node whose computation contains the stage; relation is the stage’s own
expression when it is not exactly a logical node or input, so a preview can
compile it as a subplan over from’s upstream.
Type declaration
ProgramSource
Ƭ ProgramSource:Object
Where the program was declared: its module and export.
Type declaration
CapturedProgram
Ƭ CapturedProgram:Object
Type declaration
ProgramIdentities
Ƭ ProgramIdentities:Object
Type declaration
NodeBody
Ƭ NodeBody:LogicalNode extends infer N ? N extends LogicalNode ? Omit<N, "id"> : never : never
Stable graph-shape addresses are distinct from semantic and executable
revisions. Capture refuses conflicting executable dependencies at one address.
RowOf
Ƭ RowOf<D>: D extends RelationalSource<infer R> ? R : never
Not exported: an exported type refers to it.
Type parameters
DatasetRelation
Ƭ DatasetRelation<D>: Relation<{ row: RowOf<D> ; identity: unknown ; args: never ; problems: never ; tables: never ; scan: never }>
Type parameters
InputRelations
Ƭ InputRelations<I>: { readonly [K in keyof I]: DatasetRelation<I[K]> }
Type parameters
ArgumentScalars
Ƭ ArgumentScalars<A>: { readonly [K in keyof A & string]: Scalar<Infer<A[K]>, K> }
Type parameters
RelationRowOf
Ƭ RelationRowOf<R>: R extends { relationType: { row: infer Row } } ? Row : never
Not exported: an exported type refers to it.
Type parameters
Same
Ƭ Same<A, B>: [A] extends [B] ? [B] extends [A] ? true : false : false
Not exported: an exported type refers to it.
Type parameters
RelationalOutputsMatch
Ƭ RelationalOutputsMatch<Returned, Outputs>: [Exclude<keyof Outputs, keyof Returned>] extends [never] ? [Exclude<keyof Returned, keyof Outputs>] extends [never] ? { [K in keyof Outputs]: Same<RelationRowOf<Returned[K & keyof Returned]>, RowOf<Outputs[K]>> }[keyof Outputs] extends true ? true : { relationalOutputError: `Output \{\{ [K in keyof Outputs]: Same\<RelationRowOf\<Returned[K & keyof Returned]\>, RowOf\<Outputs[K]\>\> extends true ? never : K }[keyof Outputs] & string} differs from its dataset row\` \} : \{ `relationalOutputError`: \`Undeclared output {Exclude<keyof Returned, keyof Outputs> & string}` } : { relationalOutputError: `Missing output ${Exclude<keyof Outputs, keyof Returned> & string}` }
True when the program returns exactly the declared outputs, each with its
dataset’s row; otherwise a readable refusal naming the first mismatch.
Type parameters
RelationalContext
Ƭ RelationalContext<A, I>: Object
Type parameters
Type declaration
TransformDefinition
Ƭ TransformDefinition<I, O>: Object
Type parameters
Type declaration
CheckpointOptions
Ƭ CheckpointOptions:Object
Type declaration
TransferTransport
Ƭ TransferTransport: {kind: "direct" ; source_staging: "forbid" ; max_batch_bytes: string ; max_inflight_bytes_per_reader: string ; max_concurrent_readers: number ; max_readers_per_worker: number } | { kind: "staged" ; storage: string ; target_file_bytes: string }
TransferOptions
Ƭ TransferOptions:Object
Type declaration
StagePlan
Ƭ StagePlan:Object
One stage and exactly the logical nodes it reads, in topological order.
Its relation, when present, is the last node and the only one that is not
a node of the admitted program.
Type declaration
InputDependency
Ƭ InputDependency:Object
Exact dependency coordinates. They convey neither read nor disclosure authority.
Type declaration
ProgramExecutionProfile
Ƭ ProgramExecutionProfile:Readonly<{ protocol: LaunchProtocol ; runtime: RuntimeProfile ; mode: "finite" | "checkpointed" ; replay: "deterministic" | "non_replayable" ; completion: "verified_candidate" | "provider_and_verified_candidate" ; requirements: ExecutionRequirements }>
Admitted execution semantics, independent of framework and placement.
ExecutionCompatibilityIssue
Ƭ ExecutionCompatibilityIssue:Object
Type declaration
ComputationImplementation
Ƭ ComputationImplementation<Input, Output>: Readonly<{ kind: "adapter" ; inline?: true ; build?: (args: InputRelations<Input> & InputArguments<Input>) => OutputRelations<Output> ; prepare: (context: { reference: string ; query?: string ; args: ValidatorJSON ; outputs: OutputContracts ; root_output: string | null ; guarantees?: GuaranteeBuilders ; row_keys?: { inputs: Readonly<Record<string, readonly string[]>> ; outputs: Readonly<Record<string, readonly string[]>> } }, build?: unknown) => { implementation: ComputationRepresentation ; binding: unknown ; dispatch?: "installed" ; query?: RegisteredQuery<"internal", any, any> ; required_features?: readonly string[] ; row_keys?: true ; guarantees?: true ; output_predicates?: ComputationObligations["outputPredicates"] ; evaluate?: (args: unknown, clocks?: readonly ClockObservation[]) => unknown ; inline?: (args: Readonly<Record<string, unknown>>) => Record<string, Relation<any>> } }>
A framework frontend lowers into the shared computation contract. Its
prepared binding data is compiler-local and grants no execution authority.
Type parameters
InlineComputationImplementation
Ƭ InlineComputationImplementation<I, O>: ComputationImplementation<I, O> & { inline: true }
An implementation whose prepared graph supports lexical expansion.
Type parameters
InspectionTimestamp
Ƭ InspectionTimestamp:string
Not exported: an exported type refers to it.
InspectionAbsence
Ƭ InspectionAbsence: {kind: "unknown" ; reason: "not_observed" | "incomplete_evidence" } | { kind: "unavailable" ; reason: "not_disclosed" | "expired" | "owner_unavailable" } | { kind: "not_applicable" }
Not exported: an exported type refers to it.
InspectionPartialReason
Ƭ InspectionPartialReason:"limit" | "incomplete_evidence"
Not exported: an exported type refers to it.
InspectionCollection
Ƭ InspectionCollection: {coverage: "complete" ; partial_reason: null } | { coverage: "partial" ; partial_reason: InspectionPartialReason }
Not exported: an exported type refers to it.
RetirementObservation
Ƭ RetirementObservation:Object
Retiring the producer releases only its own result interests.
Type declaration
NativeComputationInspection
Ƭ NativeComputationInspection:Object
Type declaration
ComputationPreparation
Ƭ ComputationPreparation: {state: "pending" | "unavailable" } | { state: "prepared" ; definition_digest: string ; coverage: "executed_dependencies" ; dependencies: readonly PreparedComputationDependency[] ; declared_dependencies: readonly DeclaredComputationDependency[] }
Native evidence for the closure that this run actually executed. It does
not assert current input readiness, approvals, or unexecuted consumers.
DeclaredComputationDependency
Ƭ DeclaredComputationDependency:Object
Captured definition slots, including slots not reached by this evaluation.
An empty executed_paths array grants no readiness or execution authority.
Type declaration
PreparedComputationDependency
Ƭ PreparedComputationDependency:Object
Type declaration
ComputationProgramInput
Ƭ ComputationProgramInput:Object
Not exported: an exported type refers to it.
Type declaration
Composition
Ƭ Composition:Object
Not exported: an exported type refers to it.
Type declaration
ProgramExecution
Ƭ ProgramExecution: {kind: "value" ; type: ComputationType ; value: unknown } | { kind: "raster" ; node: Extract<LogicalNode, { kind: "raster" }> ; inputs: { type: ComputationType ; value: unknown }[] } | { kind: "transform" ; node: Extract<LogicalNode, { kind: "transform" }> ; inputs: Record<string, unknown> ; parameters: Record<string, Value> } | { kind: "checkpoint" | "transfer" ; node: Extract<LogicalNode, { kind: "checkpoint" | "transfer" }> ; value: unknown }
ProgramPort
Ƭ ProgramPort:Object
Type declaration
RelationalImplementation
Ƭ RelationalImplementation:Readonly<{ kind: "relational_program" ; captured: CapturedProgram ; args: Record<string, GenericValidator> ; inputs: readonly string[] ; outputs: readonly string[] ; output_keys: Readonly<Record<string, readonly string[]>> }>
Representation
Ƭ Representation<A, R, O, N>: Readonly<{ computation: ComputationRef<A, R, O> ; output: N ; request: (ctx: { computations: Pick<Computations, "start"> }, request: { args: A ; requestKey: string }) => Promise<RunRef<A, R, O>> ; resolve: (ctx: { computations: Pick<ComputationReader, "resolve"> }, run: RunRef<A, R, O>) => Promise<OutputResolution<O[N]["value"], OutputResultKind<O[N]["kind"]>>> ; retain: (ctx: { computations: Pick<ComputationReader, "resolve"> ; results: Pick<Results, "acquire"> }, run: RunRef<A, R, O>, demand: RetentionDemand) => Promise<RepresentationCustody<O[N]["value"], OutputResultKind<O[N]["kind"]>>> }>
A named representation selects an existing computation output. It installs
no processor, execution ledger, cache, permission store or retention owner.
Type parameters
RepresentationCustody
Ƭ RepresentationCustody<T, K>: { kind: "accepted" ; result: ResultRef<T, K> ; custody: CustodyOutcome } | Exclude<OutputResolution<T, K>, { kind: "accepted" }>
Type parameters
ResultRequirements
Ƭ ResultRequirements:Object
Requirements for consuming an accepted result. Source clocks retain their
original meaning: publication age never substitutes for source coverage.
Type declaration
ExecutionVerification
Ƭ ExecutionVerification: {kind: "trusted" } | { kind: "redundant_execution" ; digest: string ; producers: ProducerEvidence[] }
What the decision may rely on about execution. trusted names the
accepting owner and executor as assumptions; nothing was re-executed.
RequiredResult
Ƭ RequiredResult<T>: Object
A current owner assessment, not a transferable permission or custody claim.
Type parameters
Type declaration
RepresentationRequest
Ƭ RepresentationRequest:Object
Feature protocol associations, never execution state or payload storage.
The feature scopes these rows to the current caller and installation and
commits them in the same transaction as admission. Keep request associations
for the promised recovery lifetime, independently of reuse entry expiry.
Type declaration
RetainedRepresentationEntry
Ƭ RetainedRepresentationEntry:RepresentationRequest & { claim: ResultClaim ; reuseUntilMs: number }
RepresentationIndex
Ƭ RepresentationIndex:Object
Type declaration
ReadContext
Ƭ ReadContext:Object
Not exported: an exported type refers to it.
Type declaration
RequestContext
Ƭ RequestContext:ReadContext & { computations: Pick<Computations, "definition" | "inspect" | "resolve" | "start"> }
Not exported: an exported type refers to it.
RetainContext
Ƭ RetainContext:ReadContext & { results: Pick<Results, "check" | "acquire" | "release"> }
Not exported: an exported type refers to it.
ReadinessRequest
Ƭ ReadinessRequest:Object
Read-only observation request sent to the application’s captured customer runner.
Type declaration
ReadinessReport
Ƭ ReadinessReport:Object
Each fact describes an actual observation. Unsupported checks stay unknown.
Type declaration
Activation
Ƭ Activation:Object
Not exported: an exported type refers to it.
Type declaration
Answer
Ƭ Answer:Object
Not exported: an exported type refers to it.
Type declaration
Issued
Ƭ Issued: {kind: "instruction" ; marker: object ; step: ExecutionInstruction } | { kind: "map" ; marker: object ; parallel: ParallelState } | { kind: "call" ; marker: object ; procedure: DurableMachine ; context: ProcedureContext ; input: unknown }
Not exported: an exported type refers to it.
DurableTemplate
Ƭ DurableTemplate:Object
Not exported: an exported type refers to it.
Type declaration
ParallelState
Ƭ ParallelState:Object
Not exported: an exported type refers to it.
Type declaration
ProgramReply
Ƭ ProgramReply: {state: "complete" ; result: string } | { state: "call" ; step: string ; frame: string ; references: string[] } | { state: "calls" ; steps: string ; frame: string ; references: string[] }
Not exported: an exported type refers to it.
ProgramContextAdapter
Ƭ ProgramContextAdapter:Object
Not exported: an exported type refers to it.
Type declaration
ResponseStage
Ƭ ResponseStage:"response" | "assumed" | "observed"
Not exported: an exported type refers to it.
Reaction
Ƭ Reaction:Object
Not exported: an exported type refers to it.
Type declaration
DurableMachine
Ƭ DurableMachine:Object
Not exported: an exported type refers to it.
Type declaration
MachineState
Ƭ MachineState:Object
Not exported: an exported type refers to it.
Type declaration
DefinitionRef
Ƭ DefinitionRef:Object
Type declaration
BindingRef
Ƭ BindingRef:Object
Type declaration
EvaluationRef
Ƭ EvaluationRef:Object
Type declaration
ResultPlacement
Ƭ ResultPlacement:Object
Type declaration
ProducerEvidence
Ƭ ProducerEvidence:Object
Type declaration
Availability
Ƭ Availability:"available" | "unavailable"
ResultPopulation
Ƭ ResultPopulation: {kind: "unknown" } | { kind: "complete" ; scope: "declared" | "caller_visible" ; scopes: { reference: string ; digest: string }[] }
Identified source-contract claims checked by the owner. This evidence does
not assert independent verification of a source or an executor.
ResultDescription
Ƭ ResultDescription<T>: Object
Type parameters
Type declaration
ResultGroup
Ƭ ResultGroup:Object
The complete accepted output manifest. It grants no aggregate custody.
Type declaration
ResolvedInput
Ƭ ResolvedInput:Object
Owner-checked placement payload; its format belongs to description.placement.
Type declaration
InputAssessment
Ƭ InputAssessment:Object
Type declaration
InputClaim
Ƭ InputClaim:Object
Type declaration
CustodyScope
Ƭ CustodyScope:Object
Not exported: an exported type refers to it.
Type declaration
SnapshotRef
Ƭ SnapshotRef:Object
Type declaration
ReadVersionRef
Ƭ ReadVersionRef:Object
Type declaration
ExactSelection
Ƭ ExactSelection: {kind: "result" ; result: ResultRef } | { kind: "read_version" ; version: ReadVersionRef }
InputSelection
Ƭ InputSelection: {kind: "result" ; result: ResultRef } | { kind: "read" ; owner: string ; reference: string ; occurrence: string ; scope_digest: string ; source_version: ReadVersionRef | null }
InputOrigin
Ƭ InputOrigin: {kind: "source" ; snapshots: SnapshotRef[] } | { kind: "derived" ; parents: string[] } | { kind: "unknown" }
ClockEvidence
Ƭ ClockEvidence:Object
Type declaration
InputEvidence
Ƭ InputEvidence:Object
Type declaration
SnapshotAssessment
Ƭ SnapshotAssessment: {state: "established" ; snapshot: SnapshotRef } | { state: "unproven" ; reason: "incomplete_provenance" | "no_common_snapshot" ; inputs: string[] } | { state: "not_applicable" }
BasisAssessmentReason
Ƭ BasisAssessmentReason:"selection_changed" | "clock_too_old" | "clock_in_future" | "retention_insufficient" | "input_missing" | "exact_selection_missing" | "incomplete_provenance" | "no_common_snapshot" | "clock_missing" | "owner_assessment_missing" | "no_source_inputs"
BasisWitness
Ƭ BasisWitness: {kind: "selection" ; selection: ExactSelection } | { kind: "snapshot" ; snapshot: SnapshotRef } | { kind: "clock" ; clock: FreshnessClockKind ; oldest_at: string ; valid_until_at: string } | { kind: "retention" ; held_until_at: string }
BasisPredicateAssessment
Ƭ BasisPredicateAssessment:Object
Type declaration
BasisOrder
Ƭ BasisOrder:"equal" | "dominates" | "dominated" | "incomparable" | "unknown"
BasisComparison
Ƭ BasisComparison:Object
Type declaration
QueryCtx
Ƭ QueryCtx:Omit<GenericQueryCtx<GenericDataModel>, "db">
Not exported: an exported type refers to it.
InstalledComputationResultOwner
Ƭ InstalledComputationResultOwner:Object
Type declaration
Q
Ƭ Q:Omit<GenericQueryCtx<GenericDataModel>, "db">
Not exported: an exported type refers to it.
M
Ƭ M:Omit<GenericMutationCtx<GenericDataModel>, "db">
Not exported: an exported type refers to it.
Version
Ƭ Version:Object
Not exported: an exported type refers to it.
Type declaration
Pin
Ƭ Pin:Object
Not exported: an exported type refers to it.
Type declaration
DatasetResultStorage
Ƭ DatasetResultStorage<Read, Write, V, P>: Object
Exact demand identity and expiry live in the existing dataset pin owner.
Type parameters
Type declaration
DeliveryReader
Ƭ DeliveryReader<V, P>: { kind: "artifact" ; read: (ctx: Q, reference: ResultRef<any, "artifact">, version: V, delivery: Value | undefined) => Promise<Value> } | { kind: "dataset" ; page: (ctx: Q, reference: ResultRef<any, "dataset">, version: V, page: ResultOwnerPageRequest, delivery: Value | undefined) => Promise<ResultOwnerPage<Value>> }
Not exported: an exported type refers to it.
Type parameters
Delivery
Ƭ Delivery<V, P>: { reader: (reference: ResultRef<any>) => DeliveryReader<V, P> } & { kind: "immediate" } | { kind: "prepared" ; prepare: (ctx: M, reference: ResultRef<any>, version: V, pin: P, demand: RetentionDemand) => Promise<{ kind: "ready" | "pending" ; receipt: Value } | { kind: "refused" ; reason: string }> ; inspect: (ctx: Q, reference: ResultRef<any>, receipt: Value, context: { version: V ; pin: P ; demand: RetentionDemand }) => Promise<{ kind: "ready" | "pending" } | { kind: "refused" ; reason: string }> ; release: (ctx: M, reference: ResultRef<any>, receipt: Value, demand: RetentionDemand) => Promise<void> }
Not exported: an exported type refers to it.
Type parameters
DatasetResultPublication
Ƭ DatasetResultPublication<V, P>: Object
Type parameters
Type declaration
ResultDefinition
Ƭ ResultDefinition<Row>: Object
Not exported: an exported type refers to it.
Type parameters
Type declaration
ComputationRequests
Ƭ ComputationRequests:Object
The installed component mints keys addressed to its own immutable native
function handles. Existing keys never follow a replacement installation.
Type declaration
ExecutionBinding
Ƭ ExecutionBinding<Args>: Object
Type parameters
Type declaration
WireShape
Ƭ WireShape: {nullable: boolean ; optional?: boolean } & { type: "string" } | { type: "reference" ; table: string } | { type: "binary" } | { type: "long" } | { type: "boolean" } | { type: "double" } | { type: "date" } | { type: "timestamp" } | { type: "null" } | { type: "missing" } | { type: "decimal" ; precision: number ; scale: number } | { type: "geometry" ; geometrySpace: GeometrySpace ; geometryTypes: GeometryKind[] } | { type: "position" ; geometrySpace: GeometrySpace } | { type: "struct" ; fields: WireColumn[] } | { type: "list" ; element: WireShape }
Not exported: an exported type refers to it.
RetentionSupport
Ƭ RetentionSupport<Read, Write>: { kind: "unsupported" } | { kind: "supported" ; protocol: ResultRetention<Read, Write> }
Type parameters
Variables
LOGICAL_PROGRAM_FORMAT
•Const LOGICAL_PROGRAM_FORMAT: "bijection.computation-program/v1"
STAGE_PLAN_FORMAT
•Const STAGE_PLAN_FORMAT: "bijection.relational-stage/v1"
declarationInspectionSchema
•Const declarationInspectionSchema: Readonly<{ $ref: "#/$defs/DeclarationInspection" = ”#/$defs/DeclarationInspection” }>
pythonCallableRuntimeProfile
•Const pythonCallableRuntimeProfile: Readonly<{ id: string ; revision: string }>
Standard worker semantic contracts. These declarations are not observations
of a provider environment or qualification receipts.
temporalWorkerRuntimeProfile
•Const temporalWorkerRuntimeProfile: Readonly<{ id: string ; revision: string }>
portableTemporalRuntimeProfile
•Const portableTemporalRuntimeProfile: Readonly<{ id: string ; revision: string }>
Exact analytical worker and kernel wire contract.
computationInspectionSchema
•Const computationInspectionSchema: Readonly<Record<string, unknown>>
runSummaryValidator
•Const runSummaryValidator: VObject<{ error: null | { code: string; message: string; } ; phase: null | string ; status: "unknown" | "waiting" | "completed" | "superseded" | "cancelled" | "expired" | "failed" | "admitted" | "running" | "incomplete" | "suspended" ; cancellation: "unknown" | "none" | "requested" }, { status: VUnion<"unknown" | "waiting" | "completed" | "superseded" | "cancelled" | "expired" | "failed" | "admitted" | "running" | "incomplete" | "suspended", VLiteral<"unknown" | "waiting" | "completed" | "superseded" | "cancelled" | "expired" | "failed" | "admitted" | "running" | "incomplete" | "suspended", "required">[], "required", never> ; phase: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; cancellation: VUnion<"unknown" | "none" | "requested", [VLiteral<"none", "required">, VLiteral<"requested", "required">, VLiteral<"unknown", "required">], "required", never> ; error: VUnion<null | { code: string ; message: string }, [VNull<null, "required">, VObject<{ code: string ; message: string }, { code: VString<string, "required"> ; message: VString<string, "required"> }, "required", "code" | "message">], "required", "code" | "message"> }, "required", "error" | "phase" | "status" | "cancellation" | "error.code" | "error.message">
availabilityReasonValidator
•Const availabilityReasonValidator: VUnion<{ kind: "absent" ; code: "runEndedWithoutOutput" ; message: string ; summary: { error: { code: string; message: string; } | null; phase: string | null; status: “unknown” | “waiting” | “completed” | “superseded” | “cancelled” | “expired” | “failed” | “admitted” | “running” | “incomplete” | “suspended”; cancellation: “unknown” | … 1 more … | “requested”; } } | { kind: "unknown" ; message: string ; detail: string } | { kind: "unavailable" ; code: "notDisclosed" | "ownerUnavailable" ; message: string } | { kind: "withheld" ; code: string ; message: string }, [VObject<{ kind: "absent" ; code: "runEndedWithoutOutput" ; message: string ; summary: { error: { code: string; message: string; } | null; phase: string | null; status: “unknown” | “waiting” | “completed” | “superseded” | “cancelled” | “expired” | “failed” | “admitted” | “running” | “incomplete” | “suspended”; cancellation: “unknown” | … 1 more … | “requested”; } }, { kind: VLiteral<"absent", "required"> ; message: VString<string, "required"> ; code: VLiteral<"runEndedWithoutOutput", "required"> ; summary: VObject<{ error: null | { code: string; message: string; } ; phase: null | string ; status: "unknown" | "waiting" | "completed" | "superseded" | "cancelled" | "expired" | "failed" | "admitted" | "running" | "incomplete" | "suspended" ; cancellation: "unknown" | "none" | "requested" }, { status: VUnion<"unknown" | "waiting" | "completed" | "superseded" | "cancelled" | "expired" | "failed" | "admitted" | "running" | "incomplete" | "suspended", VLiteral<"unknown" | "waiting" | "completed" | "superseded" | "cancelled" | "expired" | "failed" | "admitted" | "running" | "incomplete" | "suspended", "required">[], "required", never> ; phase: VUnion<null | string, [VString<string, "required">, VNull<null, "required">], "required", never> ; cancellation: VUnion<"unknown" | "none" | "requested", [VLiteral<"none", "required">, VLiteral<"requested", "required">, VLiteral<"unknown", "required">], "required", never> ; error: VUnion<null | { code: string ; message: string }, [VNull<null, "required">, VObject<{ code: string ; message: string }, { code: VString<string, "required"> ; message: VString<string, "required"> }, "required", "code" | "message">], "required", "code" | "message"> }, "required", "error" | "phase" | "status" | "cancellation" | "error.code" | "error.message"> = runSummaryValidator }, "required", "kind" | "code" | "message" | "summary" | "summary.error" | "summary.phase" | "summary.status" | "summary.cancellation" | "summary.error.code" | "summary.error.message">, VObject<{ kind: "unknown" ; message: string ; detail: string }, { kind: VLiteral<"unknown", "required"> ; detail: VString<string, "required"> ; message: VString<string, "required"> }, "required", "kind" | "message" | "detail">, VObject<{ kind: "unavailable" ; code: "notDisclosed" | "ownerUnavailable" ; message: string }, { kind: VLiteral<"unavailable", "required"> ; message: VString<string, "required"> ; code: VUnion<"notDisclosed" | "ownerUnavailable", [VLiteral<"notDisclosed", "required">, VLiteral<"ownerUnavailable", "required">], "required", never> }, "required", "kind" | "code" | "message">, VObject<{ kind: "withheld" ; code: string ; message: string }, { kind: VLiteral<"withheld", "required"> ; code: VString<string, "required"> ; message: VString<string, "required"> }, "required", "kind" | "code" | "message">], "required", "kind" | "code" | "message" | "summary" | "detail" | "summary.error" | "summary.phase" | "summary.status" | "summary.cancellation" | "summary.error.code" | "summary.error.message">
computationResults
•Const computationResults: ResultOwner
The existing native accepted manifests and file custody supply these
capabilities. No result bytes, run state or claims are copied here.
Functions
computationAddress
▸ computationAddress(value): ComputationAddress
Validate without normalizing: one definition has one wire spelling.
Parameters
Returns
ComputationAddress
computationName
▸ computationName(reference): string
Presentation only; never use this value to resolve a definition.
Parameters
Returns
string
capabilityInspection
▸ capabilityInspection<C, I, O, Q>(input): CapabilityInspection<C, I, O, Q>
Type parameters
Parameters
Returns
CapabilityInspection<C, I, O, Q>
capturedValueType
▸ capturedValueType(value): ValuePortType
Parameters
Returns
ValuePortType
captureRasterOperation
▸ captureRasterOperation(operation, inputs): CapturedValue
Raster contributes operators to this graph, with shared analysis and identity.
Parameters
Returns
CapturedValue
portType
▸ portType(program, ref): ComputationType
The logical type at a graph reference, before choosing a carrier.
Parameters
Returns
ComputationType
nodeId
▸ nodeId(body): string
Parameters
Returns
string
datasetColumns
▸ datasetColumns(dataset): Column[]
Dataset contract fields as relational columns (C1 mapping).
Parameters
Returns
Column[]
projectLocations
▸ projectLocations(frames, anchor?): Record<string, string>
Authored frames as project-relative “path:line:col”. anchor is the
declaration’s project-relative file, reported by source preparation: the
frame naming it fixes the project root. Without an anchor, a relative
(source-mapped) path is kept without its leading ./ and ../ segments.
Absolute paths outside the project are never disclosed.
Parameters
Returns
Record<string, string>
compiledCapabilities
▸ compiledCapabilities(compiled): string[]
The capabilities the SDK compiler reports a relation uses.
Parameters
Returns
string[]
stageRelation
▸ stageRelation<R>(name, relation): R
Name an intermediate relation for inspection and preview. It returns the
relation unchanged and never changes the program’s identity.
Type parameters
Parameters
Returns
R
defineTransform
▸ defineTransform<I, O>(options): TransformDefinition<I, O>
Type parameters
Parameters
Returns
TransformDefinition<I, O>
transferTransport
▸ transferTransport(value): TransferTransport
Parameters
Returns
TransferTransport
engineOf
▸ engineOf(value): Engine
Parameters
Returns
Engine
placeRelation
▸ placeRelation<R>(engine, relation): R
Type parameters
Parameters
Returns
R
checkpointRelation
▸ checkpointRelation<R>(relation, options): R
Type parameters
Parameters
Returns
R
transferRelation
▸ transferRelation<R>(relation, options): R
Type parameters
Parameters
Returns
R
programApplication
▸ programApplication(captured): (args: Readonly<Record<string, unknown>>) => { [k: string]: T; }
Expand captured expressions into their caller’s graph. Scalar substitution
is lexical; input expressions retain their own argument scope and policies.
Explicit execution boundaries remain explicit boundaries in the caller.
Parameters
Returns
fn
▸ (args): Object
Parameters
Returns
Object
captureProgram
▸ captureProgram(options): CapturedProgram
Run the authoring callback and normalize its relations into one program.
Parameters
Returns
CapturedProgram
upstreamRefs
▸ upstreamRefs(node): Ref[]
The refs a node reads.
Parameters
Returns
Ref[]
programIdentities
▸ programIdentities(program): ProgramIdentities
Parameters
Returns
ProgramIdentities
validateLogicalProgram
▸ validateLogicalProgram(value): LogicalProgram
Structural check of a stored program; workers and admission use it.
Parameters
Returns
LogicalProgram
stagePlan
▸ stagePlan(captured, name): StagePlan
The subplan a preview of name executes. Previews run on the Spark
execution resource: a stage downstream of a warehouse region is refused.
Parameters
Returns
StagePlan
validateStagePlan
▸ validateStagePlan(value, program): StagePlan
Structural check of a stored stage plan against its admitted program:
every node but the stage’s own relation is an admitted node.
Parameters
Returns
StagePlan
composeInputCustody
▸ composeInputCustody<ReadCtx, WriteCtx>(owners): InputCustody<ReadCtx, WriteCtx>
Route references to authoritative owners. This adapter creates no records
and grants no authority. Every owner implements independent retention.
Type parameters
Parameters
Returns
InputCustody<ReadCtx, WriteCtx>
completeInspection
▸ completeInspection():InspectionCollection
Returns
InspectionCollection
declarationRequirement
▸ declarationRequirement(value): DeclarationRequirement
Parameters
Returns
DeclarationRequirement
validateDeclarationInspection
▸ validateDeclarationInspection(value): DeclarationInspection
Parameters
Returns
DeclarationInspection
validateProgramExecutionProfile
▸ validateProgramExecutionProfile(profile): void
Parameters
Returns
void
executionCompatibility
▸ executionCompatibility(program, target): ExecutionCompatibilityIssue[]
Compatibility compares declared contracts; it does not attest a provider host.
Parameters
Returns
ExecutionCompatibilityIssue[]
defineExecutionProvider
▸ defineExecutionProvider<I, O>(definition): ExecutionProvider<I, O>
Adapter over the host’s existing external-call protocol for one Python or
external computation. Null is unresolved, never permission to submit again.
Reconciliation must observe the original key. Export it: the application
discovers exported bindings as it discovers computations.
Type parameters
Parameters
Returns
ExecutionProvider<I, O>
computationImplementation
▸ computationImplementation(value): unknown
Compiler-local implementation data; generated references contain none.
Parameters
Returns
unknown
inspectionKnown
▸ inspectionKnown<T>(value, evidence): Observation<T> & { kind: "known" }
These constructors project already-disclosed evidence; they confer no authority.
Type parameters
Parameters
Returns
Observation<T> & { kind: "known" }
inspectionUnknown
▸ inspectionUnknown(reason?): InspectionAbsence
Parameters
Returns
InspectionAbsence
inspectionNotApplicable
▸ inspectionNotApplicable():InspectionAbsence
Returns
InspectionAbsence
inspectionCount
▸ inspectionCount(value, kind?): InspectionCount
Parameters
Returns
InspectionCount
inspectionTimestamp
▸ inspectionTimestamp(milliseconds): InspectionTimestamp
Parameters
Returns
InspectionTimestamp
inspectionRead
▸ inspectionRead(owner, startedAt, endedAt): InspectionEvidence[]
Parameters
Returns
InspectionEvidence[]
inspectionContext
▸ inspectionContext(owner, startedAt, endedAt): InspectionContext
Parameters
Returns
InspectionContext
inspectionList
▸ inspectionList<T>(items, coverage?, reason?): InspectionCollection & { items: T[] }
Type parameters
Parameters
Returns
InspectionCollection & { items: T[] }
inspectionDefinition
▸ inspectionDefinition(definition, evidence): Object
Parameters
Returns
Object
computationInspection
▸ computationInspection(options): ComputationInspection
Every field is mandatory, including explicit unknown and inapplicable fields.
Parameters
Returns
ComputationInspection
validateComputationInspection
▸ validateComputationInspection(value): ComputationInspection
Parameters
Returns
ComputationInspection
inspectionDiagnostic
▸ inspectionDiagnostic(owner, input): InspectionDiagnostic
Diagnostics keep locations and context as data; messages are never parsed.
Parameters
Returns
InspectionDiagnostic
summarizeRun
▸ summarizeRun(inspection): RunSummary
Parameters
Returns
RunSummary
outputAvailabilityReason
▸ outputAvailabilityReason(cause): OutputAvailabilityReason
Parameters
Returns
OutputAvailabilityReason
captureOutputSelection
▸ captureOutputSelection(contracts, requested): Object
Parameters
Returns
Object
boundObservation
▸ boundObservation(value): void
Parameters
Returns
void
observationValidators
▸ observationValidators(contracts, run): Object
Parameters
Returns
Object
computationComposition
▸ computationComposition(declaration): Composition
Compiler-local pure evaluator. The installed owner supplies all execution,
step storage, child admission and resource authority. No login or durable
frame is captured here.
Parameters
Returns
Composition
computationProgram
▸ computationProgram(definition): Object
Not exported: an exported type refers to it.
Parameters
Returns
Object
executeProgram
▸ executeProgram(original, args, clocks?): Generator<ProgramExecution, Record<string, unknown>, unknown>
A single topological execution path for relation and value nodes. The
generator yields implementation work only; ordinary relations always run
through the shared analyzer and evaluator. Mutable compiler metadata is
captured before the first implementation is invoked.
Parameters
Returns
Generator<ProgramExecution, Record<string, unknown>, unknown>
evaluateProgram
▸ evaluateProgram(program, args, implementation, clocks?): Promise<Record<string, unknown>>
Parameters
Returns
Promise<Record<string, unknown>>
validatePortType
▸ validatePortType(type): ComputationType
Parameters
Returns
ComputationType
nativePortShape
▸ nativePortShape(type): WireShape
Establish native value encoding capability before choosing a carrier.
Parameters
Returns
WireShape
admitPortValue
▸ admitPortValue(type, value): JSONValue
Admit encoded native values without inferring their declared logical type.
Parameters
Returns
JSONValue
relationType
▸ relationType(columns): ComputationType
Parameters
Returns
ComputationType
relationColumns
▸ relationColumns(type): TransformationColumn[]
A row implementation must establish this capability before lowering.
Parameters
Returns
TransformationColumn[]
resolvedProgram
▸ resolvedProgram(program): ProgramArtifact
The CLI hashes these exact manifest bytes. The worker verifies them before
importing customer code. This declaration is identity, never attestation.
Parameters
Returns
ProgramArtifact
bindProgram
▸ bindProgram(program, contract): ProgramArtifact
Bind executable identity to exactly the schema delivered to a worker.
Source preparation has no generated Python dependency, so this has no hash cycle.
Parameters
Returns
ProgramArtifact
assemblePythonPrograms
▸ assemblePythonPrograms(programs, contracts?): ProgramArtifact
One graph uses one verified customer runtime and source namespace.
Parameters
Returns
ProgramArtifact
prepareRelationalImplementation
▸ prepareRelationalImplementation(context, build): ReturnType<ComputationImplementation["prepare"]>
Parameters
Returns
ReturnType<ComputationImplementation["prepare"]>
fixtureEvaluator
▸ fixtureEvaluator(program): (args: unknown, clocks: readonly ClockObservation[]) => Record<string, Record<string, Value>[]>
Parameters
Returns
fn
▸ (args, clocks?): Record<string, Record<string, Value>[]>
Parameters
Returns
Record<string, Record<string, Value>[]>
representation
▸ representation<A, R, O, N>(options): Representation<A, R, O, N>
Compose admission, original-output resolution and holder-specific custody.
Repeating a request key recovers its original native intention. Reusing an
explicit retained run is a read of that original result, never a fresh model
execution or proof of current-source completeness. Feature owners may index
these references; every resolution and acquisition still enters its owner.
Type parameters
Parameters
Returns
Representation<A, R, O, N>
retainedRepresentation
▸ retainedRepresentation<A, R, O, N>(options): Readonly<{ computation: ComputationRef<A, R, O> ; output: N ; resolve: (ctx: { computations: Pick<ComputationReader, "resolve"> }, run: Readonly<Omit<RunRef, "computation"> & { computation: ComputationRef<A, R, O> }>) => Promise<OutputResolution<O[N]["value"], OutputResultKind<O[N]["kind"]>>> ; retain: (ctx: { computations: Pick<ComputationReader, "resolve"> ; results: Pick<Results, "acquire"> }, run: Readonly<Omit<RunRef, "computation"> & { computation: ComputationRef<A, R, O> }>, demand: RetentionDemand) => Promise<RepresentationCustody<O[N]["value"], OutputResultKind<O[N]["kind"]>>> ; maxAgeMs: number ; request: (ctx: RequestContext, input: { args: A ; requestKey: string }, index: RepresentationIndex) => Promise<{ run: Readonly<Omit<RunRef, "computation"> & { computation: ComputationRef<A, R, O> }> ; source: "original" } | { run: Readonly<Omit<RunRef, "computation"> & { computation: ComputationRef<A, R, O> }> ; source: "retained" } | { run: Readonly<Omit<RunRef, "computation"> & { computation: ComputationRef<A, R, O> }> ; source: "admitted" }> ; lookup: (ctx: ReadContext, args: A, index: Pick<RepresentationIndex, "find">) => Promise<{ kind: "absent" ; entry: undefined ; run?: undefined } | { kind: "stale" ; entry: RetainedRepresentationEntry ; run?: undefined } | { kind: "current" ; entry: RetainedRepresentationEntry ; run: Readonly<Omit<RunRef, "computation"> & { computation: ComputationRef<A, R, O> }> }> ; remember: (ctx: RetainContext, requestKey: string, holder: string, index: RepresentationIndex) => Promise<{ outcome?: undefined ; entry: undefined ; kind: "not_stored" ; reason: string = “admission_closed”; resolution?: undefined = retained } | { outcome?: undefined ; entry: undefined ; kind: "output" ; resolution: { kind: "pending" } | { kind: "absent" ; reason: "run_ended_without_output" } | { kind: "unknown" ; reason: string } | { kind: "unavailable" ; reason: UnavailableOutputReason } = retained; reason?: undefined } | { entry: undefined ; resolution?: undefined = retained; kind: "custody" ; outcome: { kind: "pending" ; preparation: PreparationRef } | { kind: "refused" ; reason: string } = retained.custody; reason?: undefined } | { outcome?: undefined ; resolution?: undefined = retained; kind: "stored" ; entry: RetainedRepresentationEntry ; reason?: undefined }> }>
Explicit reuse of an original accepted output. No equivalence or fresh
execution is asserted. State, scheduling, source policies and cleanup remain
with the feature’s index and the existing native execution/result owners.
Type parameters
Parameters
Returns
Readonly<{ computation: ComputationRef<A, R, O> ; output: N ; resolve: (ctx: { computations: Pick<ComputationReader, "resolve"> }, run: Readonly<Omit<RunRef, "computation"> & { computation: ComputationRef<A, R, O> }>) => Promise<OutputResolution<O[N]["value"], OutputResultKind<O[N]["kind"]>>> ; retain: (ctx: { computations: Pick<ComputationReader, "resolve"> ; results: Pick<Results, "acquire"> }, run: Readonly<Omit<RunRef, "computation"> & { computation: ComputationRef<A, R, O> }>, demand: RetentionDemand) => Promise<RepresentationCustody<O[N]["value"], OutputResultKind<O[N]["kind"]>>> ; maxAgeMs: number ; request: (ctx: RequestContext, input: { args: A ; requestKey: string }, index: RepresentationIndex) => Promise<{ run: Readonly<Omit<RunRef, "computation"> & { computation: ComputationRef<A, R, O> }> ; source: "original" } | { run: Readonly<Omit<RunRef, "computation"> & { computation: ComputationRef<A, R, O> }> ; source: "retained" } | { run: Readonly<Omit<RunRef, "computation"> & { computation: ComputationRef<A, R, O> }> ; source: "admitted" }> ; lookup: (ctx: ReadContext, args: A, index: Pick<RepresentationIndex, "find">) => Promise<{ kind: "absent" ; entry: undefined ; run?: undefined } | { kind: "stale" ; entry: RetainedRepresentationEntry ; run?: undefined } | { kind: "current" ; entry: RetainedRepresentationEntry ; run: Readonly<Omit<RunRef, "computation"> & { computation: ComputationRef<A, R, O> }> }> ; remember: (ctx: RetainContext, requestKey: string, holder: string, index: RepresentationIndex) => Promise<{ outcome?: undefined ; entry: undefined ; kind: "not_stored" ; reason: string = “admission_closed”; resolution?: undefined = retained } | { outcome?: undefined ; entry: undefined ; kind: "output" ; resolution: { kind: "pending" } | { kind: "absent" ; reason: "run_ended_without_output" } | { kind: "unknown" ; reason: string } | { kind: "unavailable" ; reason: UnavailableOutputReason } = retained; reason?: undefined } | { entry: undefined ; resolution?: undefined = retained; kind: "custody" ; outcome: { kind: "pending" ; preparation: PreparationRef } | { kind: "refused" ; reason: string } = retained.custody; reason?: undefined } | { outcome?: undefined ; resolution?: undefined = retained; kind: "stored" ; entry: RetainedRepresentationEntry ; reason?: undefined }> }>
relationalColumns
▸ relationalColumns(schema): TransformationColumn[]
Parameters
Returns
TransformationColumn[]
relationalArguments
▸ relationalArguments(schema?): Record<string, RelationalArgument>
Parameters
Returns
Record<string, RelationalArgument>
executionProviderAdapter
▸ executionProviderAdapter<T>(adapter, provider): T
Keep readiness and native target capture attached to an exported adapter.
The adapter and a direct re-export discover the same authentic provider.
Type parameters
Parameters
Returns
T
validateDefinitionRef
▸ validateDefinitionRef(value): void
Parameters
Returns
void
validateInputAssessment
▸ validateInputAssessment(value): void
Parameters
Returns
void
validateResultDescription
▸ validateResultDescription(value): void
Parameters
Returns
void
emptyBasisRequirements
▸ emptyBasisRequirements():BasisRequirements
Returns
BasisRequirements
computationEvidenceDigest
▸ computationEvidenceDigest(value): string
Parameters
Returns
string
emptyComputationBasis
▸ emptyComputationBasis():ComputationBasis
Returns
ComputationBasis
validateComputationBasis
▸ validateComputationBasis(basis): void
Parameters
Returns
void
composeComputationBasis
▸ composeComputationBasis(...bases): ComputationBasis
Pure union. Names must already be qualified by the composing owner.
Parameters
Returns
ComputationBasis
bindComputationEvidence
▸ bindComputationEvidence(basis, name, evidence): ComputationBasis
Parameters
Returns
ComputationBasis
bindComputationResult
▸ bindComputationResult(basis, name, result, parent, clocks?): ComputationBasis
Parameters
Returns
ComputationBasis
assessComputationSnapshot
▸ assessComputationSnapshot(basis, inputs?): SnapshotAssessment
Explanation only. Admission must obtain the records from their owners.
Parameters
Returns
SnapshotAssessment
validateBasisRequirements
▸ validateBasisRequirements(requirements): asserts requirements is BasisRequirements
Parameters
Returns
asserts requirements is BasisRequirementsexactSelection
▸ exactSelection(node): ExactSelection | null
Equality concerns selected contents, independently of read occurrences and clocks.
Parameters
Returns
ExactSelection | null
computationSelections
▸ computationSelections(basis): Record<string, ExactSelection>
Parameters
Returns
Record<string, ExactSelection>
assessComputationInputs
▸ assessComputationInputs(basis, requirements, owners, now, expected?): BasisAssessment
Project current exact-owner holds, without inheriting acquisition receipts
or inferring result custody from a source snapshot.
Parameters
Returns
BasisAssessment
assessComputationRequirements
▸ assessComputationRequirements(basis, requirements, holds, now, expected?): BasisAssessment
Explanation over owner-validated facts. Without admitted selections, fixed
remains unproven. Admission also verifies receipts and current authority.
Parameters
Returns
BasisAssessment
combineBasisRequirements
▸ combineBasisRequirements(...requirements): BasisRequirements
Requirement composition can only strengthen a consumer’s obligations.
Parameters
Returns
BasisRequirements
datasetVersionBasis
▸ datasetVersionBasis(owner, reference, version, metadata): ComputationBasis
A capture’s recorded source identity is not a database-wide snapshot
attestation. Older/incomplete source metadata remains explicit uncertainty.
Parameters
Returns
ComputationBasis
datasetVersionClocks
▸ datasetVersionClocks(metadata): ClockEvidence[]
Clock coordinates from the dataset owner’s exact immutable version metadata.
Parameters
Returns
ClockEvidence[]
computationCustodyRelease
▸ computationCustodyRelease():boolean
A native cleanup scope conveys no permission to read retained data.
Returns
boolean
openComputationInput
▸ openComputationInput(ctx, reference): Promise<ResolvedInput>
Resolve only an input already held by the native evaluation. The owner
rechecks current access before releasing any payload or data locator.
Parameters
Returns
Promise<ResolvedInput>
readComputationInput
▸ readComputationInput<T>(ctx, reference): Promise<T>
Read a structured native artifact. Remote placement payloads stay explicit
through openComputationInput; a dataset manifest is never typed as its rows.
Type parameters
Parameters
Returns
Promise<T>
selectedComputationDefinition
▸ selectedComputationDefinition(ctx, declaration): Promise<DefinitionRef>
Installation adapters must not silently replace a selected dependency’s
parameters or nested bindings with the default installed declaration. The
owner revision captured in the same query is the later admission precondition.
Parameters
Returns
Promise<DefinitionRef>
computationInvocation
▸ computationInvocation(): {run_id: string ; step_id: string ; operation: CustodyScope["operation"] } | null
Native parentage is provenance, never caller-supplied authority.
Returns
{run_id: string ; step_id: string ; operation: CustodyScope["operation"] } | null
computationExecution
▸ computationExecution<Ref>(computation, owner, options?): Ref
Component adapters register their existing owner for discovery.
This creates no admission, retention or execution state.
Type parameters
Parameters
Returns
Ref
requireExternalRuntimeAdmission
▸ requireExternalRuntimeAdmission():Promise<void>
Native guard for a new root external command. Call after duplicate recovery,
in the command’s admission transaction. Native child custody remains valid.
Returns
Promise<void>
requireExternalRuntimePlan
▸ requireExternalRuntimePlan(plan): Promise<void>
Fence only a new scheduler occurrence. Recover its original request first.
Parameters
Returns
Promise<void>
transferredFileResult
▸ transferredFileResult<V, P>(options): Object
A dataset owner can pin a private native transfer, then adopt its verified
bytes only in the complete result group’s publication transaction. Publication
consent is separate from the dataset’s read and retention policy. accept
must record the resulting file in that owner’s native file-capture record;
it does not change the immutable version manifest. This adapter supplies no
byte-delivery capability. Readers and input delivery remain explicit.
Private claims must fit within the native staging deadline. Ending one pin
does not cancel a shared transfer: its producer owns cancellation, and native
storage reclaims expired preparation independently of the pin’s cleanup.
Type parameters
Parameters
Returns
Object
workloadFileDelivery
▸ workloadFileDelivery<V, P>(options): Delivery<V, P>
Prepare an exact file disclosure to the component retaining this resource
callback. Dataset pins still own result custody; native file grants own byte
permission and erasure. Receipts contain no delivery credential. Use with
input: workloadFileInput() and an explicit file placement contract.
Type parameters
Parameters
Returns
Delivery<V, P>
workloadFileInput
▸ workloadFileInput<V, P>(): Object
Mint delivery only inside the execution owner’s fenced input mutation.
Each credential is bounded by the original admitted grant; queries can
inspect that grant without minting or renewing a delivery.
Type parameters
Returns
Object
defineDatasetResultOwner
▸ defineDatasetResultOwner<D, V, P>(options): Readonly<{ owner: ResultOwner<Q, M> ; placement: ResultPlacement ; reference: <K>(ctx: Q, name: K, id: string) => Promise<ResultRef<Infer<D[K]["row"]>, D[K] extends { kind: infer Kind } ? Kind : "dataset">> }>
Adapt the dataset owner’s pins and byte delivery without another claim
table, execution journal, serving head or payload store.
Type parameters
Parameters
Returns
Readonly<{ owner: ResultOwner<Q, M> ; placement: ResultPlacement ; reference: <K>(ctx: Q, name: K, id: string) => Promise<ResultRef<Infer<D[K]["row"]>, D[K] extends { kind: infer Kind } ? Kind : "dataset">> }>
datasetResultReference
▸ datasetResultReference<Row>(definition, version, options?): Promise<ResultRef<Row, "dataset">>
Type parameters
Parameters
Returns
Promise<ResultRef<Row, "dataset">>
▸ datasetResultReference<Row, Kind>(definition, version, options): Promise<ResultRef<Row, Kind>>
Type parameters
Parameters
Returns
Promise<ResultRef<Row, Kind>>
registerExecutionOwner
▸ registerExecutionOwner<T, P>(value, owner): T & { _execution?: P }
Installation evidence only. A serialized object cannot install host code.
Type parameters
Parameters
Returns
T & { _execution?: P }
executionOwner
▸ executionOwner(value): ExecutionOwner
Parameters
Returns
ExecutionOwner
bindRelationArguments
▸ bindRelationArguments(expression, bindings): RelationExpression
Bind a captured relation’s own scalar arguments. Inserted expressions keep
their caller’s scope, and literal objects are never interpreted as syntax.
Parameters
Returns
RelationExpression
combineReadRequirements
▸ combineReadRequirements(...policies): ReadRequirements
Combine requirements without letting a consumer weaken its view’s policy.
Parameters
Returns
ReadRequirements
bindRelationSources
▸ bindRelationSources(expression, sources, args): Relation<any>
Substitute scalar arguments before source relations. Caller expressions
retain their lexical scope, population restrictions and read obligations.
Parameters
Returns
Relation<any>
setupResultReaderFromRequest
▸ setupResultReaderFromRequest(request): ResultReader
Internal transport seam for an execution owner’s fenced input reader. The
public reader keeps the same validation and native-value decoding.
Parameters
Returns
ResultReader