{ "kind": "runlocal.terminology", "protocol_version": "5.1", "url": "https://www.runlocal.ai/schemas/v1/terminology.json", "describes": "runlocal.workload/5.1", "reading_order": [ "files", "functions", "entrypoints", "examples", "optimize", "knowledge", "extensions" ], "keys": ". defines a field name, .. a fixed value of that field, and . a fixed value the definition takes directly. is a name under $defs in the request schema, or WorkloadRequest for the top of the document. A field of a record written inline keeps the fields above it, as in StateSlot.initial.constant. The definition and the field never contain a dot; everything after them is the value, as in WorkloadRequest.kind.runlocal.workload.", "namespaces": [ "WorkloadRequest", "RequestLink", "Source", "SourceCoverage", "Configuration", "BaselineRelationship", "DimensionRange", "Dimension", "WeightPort", "WeightLift", "WeightPorts", "WeightDefaults", "ValueDomain", "WeightLocation", "ParentWeight", "UniformGeneratedValue", "IntegerGeneratedValue", "FixedGeneratedValue", "NoValueSource", "LocalValueSource", "FileValueSource", "ConstantValueSource", "ValueBinding", "WeightGroupBinding", "OutputBinding", "ValueStatistics", "File", "UrlFileLocation", "StoredFileLocation", "Function", "InputPort", "StatePair", "UnknownRef", "Contract", "Numerics", "QuantizationOverlay", "QuantizedWeight", "QuantizedWeightDefaults", "QuantizedValue", "OnnxAffineQuantization", "LocalQuantizationTensor", "FileQuantizationTensor", "QuantizationImplicitZeroPoint", "QuantizationStoredZeroPoint", "QuantizationPerTensor", "QuantizationPerAxis", "QuantizationBlocked", "StaticQuantizationParameters", "DynamicQuantizationParameters", "Reference", "Layout", "SideEffects", "Aliasing", "AliasPair", "Observe", "GraphBody", "ExternalData", "StepsBody", "Step", "ValueRef", "BlackBox", "Missing", "Entrypoint", "WeightSlot", "TiedPair", "StateSlot", "Constant", "TorchEnvironment", "OnnxOperator", "TorchOperator", "TorchApiDefinition", "TorchSourceDefinition", "TorchModuleDefinition", "OperatorSemantics", "Target", "Where", "Select", "Example", "KnowledgePurpose", "UnknownKnowledge", "EvidenceKnowledge", "FidelityMetric", "FidelityInterface", "FidelityEvidence", "Tool", "Confidence", "ExtensionDefinition", "Extension" ], "terms": { "WorkloadRequest.kind": { "meaning": "What this document is. Always runlocal.workload." }, "WorkloadRequest.kind.runlocal.workload": { "meaning": "The document kind of a model graph request." }, "WorkloadRequest.protocol_version": { "meaning": "The version of this specification the document follows." }, "WorkloadRequest.protocol_version.5.1": { "meaning": "The current protocol version. It defines quantization as an overlay on a float function, and it lets a json file write its value in the request.", "was": "5.0" }, "WorkloadRequest.name": { "meaning": "The model's name, the same across versions.", "was": "lineage" }, "WorkloadRequest.version": { "meaning": "This version of the request; name and version together identify one revision digest.", "was": "revision" }, "WorkloadRequest.previous": { "meaning": "The revision digest of the version this one replaces, or null for the first.", "was": "parent" }, "WorkloadRequest.note": { "meaning": "Free text for people reviewing the document. Notes count toward the revision digest and never toward the contract or example digests, so they cannot change what is asked." }, "WorkloadRequest.links": { "meaning": "External context links. They affect only the revision digest and never define computation." }, "WorkloadRequest.baseline": { "meaning": "The baseline model used for fidelity comparison, or null. It affects the revision digest only." }, "WorkloadRequest.source": { "meaning": "Where the model comes from: the customer's program, its version, and whether this document covers it completely.", "was": "source_scope" }, "WorkloadRequest.files": { "meaning": "Every file sent with the request, by name, with its role, format, size, and digest. Nothing unlisted is sent.", "was": "objects" }, "WorkloadRequest.functions": { "meaning": "The model's functions, by name. Each has inputs, outputs, a contract, and a body.", "was": "callables" }, "WorkloadRequest.entrypoints": { "meaning": "The ways to call the model, keyed by the source's names for them. Each names a function and binds its state.", "was": "entries" }, "WorkloadRequest.weights": { "meaning": "Named weights at program scope for steps to bind. Empty when no function composes others with weights.", "was": "parameters" }, "WorkloadRequest.weights.*": { "meaning": "Written-form shorthand: terms that every other entry of this map shares. An entry's own field wins. Elaboration merges this entry and removes it, so it is never a name." }, "WorkloadRequest.tied_weights": { "meaning": "Pairs of weights that hold the same values, such as an embedding and an output head. Only this list establishes tying.", "was": "parameter_relations: equal_values" }, "WorkloadRequest.state": { "meaning": "Persistent values such as caches, by name. Empty for a stateless model.", "was": "resources" }, "WorkloadRequest.constants": { "meaning": "Public constants outside any graph, by name. Never taken from sample files." }, "WorkloadRequest.environments": { "meaning": "Pinned Python and package versions used by Torch graphs." }, "WorkloadRequest.operators": { "meaning": "The request's operator registry. Every graph node names one ONNX or Torch entry." }, "WorkloadRequest.examples": { "meaning": "Situations to optimize for, by name: an entrypoint, its inputs and weights, what holds, and what was measured.", "was": "workloads" }, "WorkloadRequest.optimize": { "meaning": "The parts of the model to optimize, by name. Each target says where and what it selects. An empty map means every entrypoint with its whole body.", "was": "regions" }, "WorkloadRequest.knowledge": { "meaning": "Questions and evidence, by name. Each entry states its purpose, subjects, and dependencies.", "was": "unknowns and checks" }, "WorkloadRequest.extensions": { "meaning": "Extensions this document uses, by name: features the base document does not express.", "was": "profiles" }, "RequestLink.url": { "meaning": "An HTTPS reference without credentials or access tokens. The server never fetches it." }, "RequestLink.kind": { "meaning": "The purpose of the external reference." }, "RequestLink.kind.configuration": { "meaning": "Upstream settings for reference. Actual settings belong in source.configuration." }, "RequestLink.kind.model_card": { "meaning": "A page that describes the model." }, "RequestLink.kind.implementation": { "meaning": "Source code for reference. It does not define the submitted computation." }, "RequestLink.kind.paper": { "meaning": "A research paper." }, "RequestLink.kind.documentation": { "meaning": "Documentation for the request." }, "RequestLink.kind.other": { "meaning": "Other external reference material." }, "RequestLink.title": { "meaning": "A short display label." }, "RequestLink.note": { "meaning": "Free text for people reviewing this external reference. Notes count toward the revision digest and never toward the contract or example digests, so they cannot change what is asked." }, "RequestLink.scope": { "meaning": "An existing JSON Pointer in the written request. Omitted, null, or empty means the whole request." }, "Source.configuration": { "meaning": "The resolved model family, preset, and settings used to build the graph. null when not recorded." }, "Source.name": { "meaning": "A short name for the customer's program or repository. It is not a URL." }, "Source.version": { "meaning": "The version, commit, or tag of the customer's program." }, "Source.coverage": { "meaning": "Whether the document covers the source completely. An incomplete source names fact-purpose unknowns.", "was": "complete" }, "SourceCoverage.kind": { "meaning": "Whether source coverage is complete or incomplete." }, "SourceCoverage.kind.complete": { "meaning": "The document covers every relevant source behavior." }, "SourceCoverage.kind.incomplete": { "meaning": "The document does not cover every relevant source behavior." }, "SourceCoverage.unknowns": { "meaning": "Fact-purpose unknowns that state what source behavior is missing." }, "Configuration.family": { "meaning": "The model family." }, "Configuration.variant": { "meaning": "The selected preset name, such as tiny or 9b." }, "Configuration.values": { "meaning": "Resolved JSON settings. Strings are literal text. The graph defines the computation." }, "BaselineRelationship.contract": { "meaning": "The baseline model contract digest." }, "BaselineRelationship.revision": { "meaning": "The baseline request revision digest, or null." }, "BaselineRelationship.title": { "meaning": "A short label for the baseline model." }, "DimensionRange.min": { "meaning": "The least permitted extent, included in the range." }, "DimensionRange.max": { "meaning": "The greatest permitted extent, included in the range." }, "Dimension.min": { "meaning": "The least permitted extent, included in the range." }, "Dimension.max": { "meaning": "The greatest permitted extent, included in the range." }, "Dimension.multiple_of": { "meaning": "Every permitted extent is a multiple of this positive integer." }, "Dimension.equals": { "meaning": "A relation to other dimensions in the same function, or null." }, "Dimension.equals.sum": { "meaning": "This dimension equals the sum of the named dimensions. Dependencies have no cycle." }, "WeightPort.type": { "meaning": "The logical element type and shape, independent of packing." }, "WeightPort.private": { "meaning": "Whether actual values must stay on the client's machine.", "was": "disclosure: local_only" }, "WeightPort.access": { "meaning": "Weights are read-only." }, "WeightPort.access.read": { "meaning": "Calls read the weight and never change its values." }, "WeightPort.supplied": { "meaning": "When the port's values are bound: at_runtime or prepared_locally.", "was": "binding" }, "WeightPort.supplied.at_runtime": { "meaning": "Bound when the model runs.", "was": "runtime" }, "WeightPort.supplied.prepared_locally": { "meaning": "Prepared on the customer's machine before use; no packed format is implied.", "was": "local_preparation" }, "WeightPort.lives": { "meaning": "How long the bound values stay fixed.", "was": "lifetime" }, "WeightPort.lives.per_call": { "meaning": "The value is fixed during one call.", "was": "invocation" }, "WeightPort.lives.per_session": { "meaning": "The value is fixed until the customer-local session ends.", "was": "session" }, "WeightPort.domain": { "meaning": "The value domain: restrictions that every value supplied to this port must satisfy.", "was": "values" }, "WeightLift.lift": { "meaning": "The prefix of the enclosing port names. Called port p binds to the enclosing port .p, or to p when the prefix is empty. An undeclared enclosing port gets the called port's record." }, "WeightPorts.*": { "meaning": "Written-form shorthand: terms that every other entry of this map shares. An entry's own field wins. Elaboration merges this entry and removes it, so it is never a name." }, "WeightDefaults.private": { "meaning": "The disclosure policy that every entry of the map shares, unless an entry states its own." }, "WeightDefaults.access": { "meaning": "Weights are read-only." }, "WeightDefaults.access.read": { "meaning": "Calls read the weight and never change its values." }, "WeightDefaults.supplied": { "meaning": "When values are bound, for every entry of the map that does not state its own." }, "WeightDefaults.supplied.at_runtime": { "meaning": "Bound when the model runs.", "was": "runtime" }, "WeightDefaults.supplied.prepared_locally": { "meaning": "Prepared on the customer's machine before use; no packed format is implied.", "was": "local_preparation" }, "WeightDefaults.lives": { "meaning": "How long bound values stay fixed, for every entry of the map that does not state its own." }, "WeightDefaults.lives.per_call": { "meaning": "The value is fixed during one call.", "was": "invocation" }, "WeightDefaults.lives.per_session": { "meaning": "The value is fixed until the customer-local session ends.", "was": "session" }, "WeightDefaults.domain": { "meaning": "The value domain that every entry of the map shares. An entry's own restrictions merge over them, field by field.", "was": "values" }, "ValueDomain.finite": { "meaning": "Whether NaN and infinities are excluded." }, "ValueDomain.minimum": { "meaning": "The inclusive lower value bound, or null. A bound also excludes NaN." }, "ValueDomain.maximum": { "meaning": "The inclusive upper value bound, or null. A bound also excludes NaN." }, "ValueDomain.distinct": { "meaning": "The required number of distinct tensor elements, or null." }, "WeightLocation.graph_input": { "meaning": "The main-graph input name, when it differs from the weight port name.", "was": "role: parameter" }, "ParentWeight.port": { "meaning": "A weight port of the enclosing function. Reusing it shares one logical weight." }, "UniformGeneratedValue.kind": { "meaning": "The value source kind." }, "UniformGeneratedValue.kind.generated": { "meaning": "Synthetic values created locally." }, "UniformGeneratedValue.generator": { "meaning": "The generator algorithm." }, "UniformGeneratedValue.generator.uniform": { "meaning": "Uniform synthetic values before element conversion." }, "UniformGeneratedValue.version": { "meaning": "The generator algorithm version." }, "UniformGeneratedValue.version.1": { "meaning": "The uniform-v1 algorithm in SEMANTICS.md." }, "UniformGeneratedValue.seed": { "meaning": "An unsigned 32-bit seed. Zero is allowed." }, "UniformGeneratedValue.lower": { "meaning": "The inclusive lower endpoint before element conversion." }, "UniformGeneratedValue.upper": { "meaning": "The exclusive upper endpoint before element conversion. Rounding can include it." }, "IntegerGeneratedValue.kind": { "meaning": "The value source kind." }, "IntegerGeneratedValue.kind.generated": { "meaning": "Synthetic values created locally." }, "IntegerGeneratedValue.generator": { "meaning": "The generator algorithm." }, "IntegerGeneratedValue.generator.integer": { "meaning": "Unbiased integer values from an inclusive range." }, "IntegerGeneratedValue.version": { "meaning": "The generator algorithm version." }, "IntegerGeneratedValue.version.1": { "meaning": "The integer-v1 algorithm in SEMANTICS.md." }, "IntegerGeneratedValue.seed": { "meaning": "An unsigned 32-bit seed. Zero is allowed." }, "IntegerGeneratedValue.lower": { "meaning": "The inclusive lower integer." }, "IntegerGeneratedValue.upper": { "meaning": "The inclusive upper integer." }, "FixedGeneratedValue.kind": { "meaning": "The value source kind." }, "FixedGeneratedValue.kind.generated": { "meaning": "Synthetic values created locally." }, "FixedGeneratedValue.generator": { "meaning": "The generator algorithm." }, "FixedGeneratedValue.generator.fixed": { "meaning": "One value repeated for every logical element." }, "FixedGeneratedValue.version": { "meaning": "The generator algorithm version." }, "FixedGeneratedValue.version.1": { "meaning": "The fixed-v1 algorithm in SEMANTICS.md." }, "FixedGeneratedValue.seed": { "meaning": "An unsigned 32-bit seed retained for a stable group-source shape." }, "FixedGeneratedValue.value": { "meaning": "The repeated value before element conversion." }, "NoValueSource.kind": { "meaning": "The source kind." }, "NoValueSource.kind.none": { "meaning": "No value is supplied. The caller supplies it later. It is neither a zero tensor nor an unknown type.", "was": "unbound" }, "LocalValueSource.kind": { "meaning": "The source kind." }, "LocalValueSource.kind.local": { "meaning": "Values kept on the customer's machine." }, "LocalValueSource.binding": { "meaning": "A local name. The server never follows it." }, "LocalValueSource.digest": { "meaning": "The SHA-256 of the exact local bytes. It identifies the values and does not send them." }, "FileValueSource.kind": { "meaning": "The source kind." }, "FileValueSource.kind.file": { "meaning": "Values in a sample file. The location of the file states where its bytes are.", "was": "sample" }, "FileValueSource.file": { "meaning": "A file with role sample that contains the value." }, "FileValueSource.key": { "meaning": "The name of one tensor in a file that holds many, such as a safetensors or npz file." }, "ConstantValueSource.kind": { "meaning": "The source kind." }, "ConstantValueSource.kind.constant": { "meaning": "A named public constant supplies the value.", "was": "fixed" }, "ConstantValueSource.constant": { "meaning": "The constant that supplies the value." }, "ValueBinding.source": { "meaning": "Where the value comes from." }, "ValueBinding.holds": { "meaning": "Whether the values are one representative case or hold for every run that the example stands for." }, "ValueBinding.holds.example": { "meaning": "One representative case. The result must stay correct for other values." }, "ValueBinding.holds.every_run": { "meaning": "Each run that the example stands for uses exactly these values. The service can use them to check, calibrate, or compare a result. It never builds them into the computation.", "was": "specialization_constant" }, "ValueBinding.statistics": { "meaning": "Measurements of these values. They do not promise facts about another run." }, "WeightGroupBinding.source": { "meaning": "Where all otherwise unbound weights in the group come from." }, "WeightGroupBinding.holds": { "meaning": "Whether the values are one representative case or hold for every run that the example stands for." }, "WeightGroupBinding.holds.example": { "meaning": "One representative case. The result must stay correct for other values." }, "WeightGroupBinding.holds.every_run": { "meaning": "Each run that the example stands for uses exactly these values." }, "WeightGroupBinding.statistics": { "meaning": "Measurements of these values. They do not promise facts about another run." }, "OutputBinding.source": { "meaning": "Where the reference value of the output is: no value, a value that stays local, or a sample file that the service can read." }, "OutputBinding.statistics": { "meaning": "Measurements of the reference value. A summary to compare against when the file itself is not written." }, "OutputBinding.tolerance": { "meaning": "The accepted difference between the output of the computation on the example values and the reference, as text with its metric. The user decides it." }, "ValueStatistics.minimum": { "meaning": "The smallest measured element." }, "ValueStatistics.maximum": { "meaning": "The largest measured element." }, "ValueStatistics.nonzero_fraction": { "meaning": "The measured fraction of elements that are not zero." }, "ValueStatistics.distinct": { "meaning": "The measured number of different element values." }, "File.role": { "meaning": "What a file is for: model, sample, evidence, or extension." }, "File.role.model": { "meaning": "Part of what is being asked, counted in the contract digest. The JSON graph, an optional source artifact, and constant tensors have this role.", "was": "semantic" }, "File.role.sample": { "meaning": "Example values, counted in the digest of the examples that use them." }, "File.role.evidence": { "meaning": "An artifact an evidence entry refers to." }, "File.role.extension": { "meaning": "A schema or specification file an extension names, counted in the contract digest." }, "File.format": { "meaning": "How to parse a file's bytes: onnx/@, json, or bytes/." }, "File.content": { "meaning": "The value of a json file, written in the request itself, so that a reader of the request sees the whole file. The bytes of such a file are the canonical JSON of the value under RFC 8785, so it states no size_bytes and no digest and sends no base64." }, "File.size_bytes": { "meaning": "The exact byte length of a file before parsing. A file that writes its content states no size_bytes." }, "File.digest": { "meaning": "SHA-256 of the file's exact bytes, written as sha256: and 64 hex digits. A file that writes its content states no digest." }, "File.location": { "meaning": "Where the bytes of the file are, when they do not travel with the request. It states what the customer made available to the service. It is not part of the contract digest or of an example digest." }, "File.note": { "meaning": "Free text for people reviewing the file. Notes count toward the revision digest and never toward the contract or example digests, so they cannot change what is asked." }, "UrlFileLocation.kind": { "meaning": "The location kind." }, "UrlFileLocation.kind.url": { "meaning": "The bytes are public at a URL." }, "UrlFileLocation.url": { "meaning": "A public https URL of the exact bytes. It needs no credentials, and the digest of the file pins the bytes." }, "StoredFileLocation.kind": { "meaning": "The location kind." }, "StoredFileLocation.kind.stored": { "meaning": "The bytes are in the Runlocal object store, and the digest of the file finds them." }, "Function.weights": { "meaning": "Logical weight ports by stable name. This is the only weight interface. An empty map declares no weights." }, "Function.dimensions": { "meaning": "Named dimension domains for this function. They apply to every call." }, "Function.inputs": { "meaning": "The function's inputs by name, with their types." }, "Function.outputs": { "meaning": "The function's outputs by name, with their types." }, "Function.state": { "meaning": "The state the function reads or writes, by name, bound to a state slot by each entrypoint or step.", "was": "resources" }, "Function.constraints": { "meaning": "Conditions written as text over shapes, such as N <= 4096, that every call must satisfy.", "was": "domain" }, "Function.contract": { "meaning": "The terms under which a replacement is judged; omitted means the base contract." }, "Function.quantization": { "meaning": "Quantization substitutions outside the float body. An empty overlay means this function is not quantized." }, "Function.body": { "meaning": "How the function is defined: graph, steps, black_box, missing, or extension." }, "Function.note": { "meaning": "Free text for people reviewing the function. Notes count toward the revision digest and never toward the contract or example digests, so they cannot change what is asked." }, "InputPort.type": { "meaning": "The input's tensor type." }, "InputPort.private": { "meaning": "Whether actual values must stay on the client's machine." }, "InputPort.domain": { "meaning": "The value domain: restrictions that every value supplied to this input must satisfy.", "was": "values" }, "StatePair.read": { "meaning": "The ordinary input port that receives the session value before the call." }, "StatePair.write": { "meaning": "The ordinary output port that returns the session value after the call." }, "UnknownRef.unknown": { "meaning": "Written as {\"unknown\": \"\"} in place of a value the author does not know. It names a fact-purpose unknown knowledge entry and never grants freedom.", "was": "{kind: unknown, requirement}" }, "Contract.numerics": { "meaning": "The numerical term: as_written, an extension, or {unknown}." }, "Contract.reference": { "meaning": "What a correctness claim compares against: math, an extension pinning a runtime, or {unknown}." }, "Contract.layout": { "meaning": "The memory interface term: any, an extension, or {unknown}.", "was": "abi" }, "Contract.observe": { "meaning": "What counts as an observable result: outputs, an extension, or {unknown}.", "was": "observations" }, "Numerics.as_written": { "meaning": "The body's own operations define the permitted numerical outcomes: nothing narrower, nothing wider.", "was": "body_defined" }, "QuantizationOverlay.weights": { "meaning": "Logical float weight ports and their stored quantized forms." }, "QuantizationOverlay.weights.*": { "meaning": "Written-form shorthand: the scheme that every other entry of this map shares. An entry's own field wins. Elaboration merges this entry and removes it, so it is never a name." }, "QuantizationOverlay.values": { "meaning": "Named float graph values and their quantize-dequantize substitutions." }, "QuantizationOverlay.storage": { "meaning": "A named extension that maps logical quantized tensors to their physical stored bytes." }, "QuantizedWeight.scheme": { "meaning": "The exact checked ONNX affine scheme." }, "QuantizedWeight.codes": { "meaning": "The customer-owned stored codes." }, "QuantizedWeight.scale": { "meaning": "The customer-owned stored scale." }, "QuantizedWeight.zero_point": { "meaning": "The stored or implicit affine zero point." }, "QuantizedWeightDefaults.scheme": { "meaning": "The affine scheme that every entry of the map shares, unless an entry states its own." }, "QuantizedValue.scheme": { "meaning": "The exact checked ONNX affine scheme." }, "QuantizedValue.parameters": { "meaning": "Static stored parameters or the checked dynamic rule." }, "OnnxAffineQuantization.kind": { "meaning": "The affine scheme kind. Always onnx_affine." }, "OnnxAffineQuantization.kind.onnx_affine": { "meaning": "Affine quantization defined by checked ONNX QDQ schemas." }, "OnnxAffineQuantization.domain": { "meaning": "The ONNX domain. It is the standard empty domain." }, "OnnxAffineQuantization.domain.": { "meaning": "The standard ONNX domain." }, "OnnxAffineQuantization.opset": { "meaning": "The imported ONNX opset used to resolve the schemas." }, "OnnxAffineQuantization.quantize_schema_version": { "meaning": "The exact resolved QuantizeLinear schema version." }, "OnnxAffineQuantization.dequantize_schema_version": { "meaning": "The exact resolved DequantizeLinear schema version." }, "OnnxAffineQuantization.code_type": { "meaning": "The code element type." }, "OnnxAffineQuantization.code_type.int2": { "meaning": "Signed 2-bit integer codes." }, "OnnxAffineQuantization.code_type.uint2": { "meaning": "Unsigned 2-bit integer codes." }, "OnnxAffineQuantization.code_type.int4": { "meaning": "Signed 4-bit integer codes." }, "OnnxAffineQuantization.code_type.uint4": { "meaning": "Unsigned 4-bit integer codes." }, "OnnxAffineQuantization.code_type.int8": { "meaning": "Signed 8-bit integer codes." }, "OnnxAffineQuantization.code_type.uint8": { "meaning": "Unsigned 8-bit integer codes." }, "OnnxAffineQuantization.code_type.int16": { "meaning": "Signed 16-bit integer codes." }, "OnnxAffineQuantization.code_type.uint16": { "meaning": "Unsigned 16-bit integer codes." }, "OnnxAffineQuantization.code_type.float8e4m3fn": { "meaning": "Finite 8-bit E4M3FN floating-point codes." }, "OnnxAffineQuantization.granularity": { "meaning": "How parameters broadcast over the logical tensor." }, "LocalQuantizationTensor.kind": { "meaning": "The stored tensor source. Always local." }, "LocalQuantizationTensor.kind.local": { "meaning": "A private tensor in the selected local weight source." }, "LocalQuantizationTensor.binding": { "meaning": "The tensor name relative to the selected local weight source." }, "LocalQuantizationTensor.type": { "meaning": "The tensor's exact type and shape." }, "FileQuantizationTensor.kind": { "meaning": "The stored tensor source. Always file." }, "FileQuantizationTensor.kind.file": { "meaning": "A public tensor in a bundled quantization-tensor document." }, "FileQuantizationTensor.file": { "meaning": "The bundled model JSON file that contains the tensor." }, "FileQuantizationTensor.tensor": { "meaning": "The tensor name in the bundled quantization-tensor document." }, "FileQuantizationTensor.type": { "meaning": "The stored tensor's logical type and shape." }, "QuantizationImplicitZeroPoint.kind": { "meaning": "The zero-point form. Always implicit_zero." }, "QuantizationImplicitZeroPoint.kind.implicit_zero": { "meaning": "No stored zero point. It gives uint8 codes unless the pinned QuantizeLinear schema has output_dtype, so int8 codes under an older schema need a stored zero point of zeros." }, "QuantizationStoredZeroPoint.kind": { "meaning": "The zero-point form. Always stored." }, "QuantizationStoredZeroPoint.kind.stored": { "meaning": "A customer-owned stored zero-point tensor." }, "QuantizationStoredZeroPoint.tensor": { "meaning": "The stored zero-point tensor." }, "QuantizationPerTensor.kind": { "meaning": "The granularity. Always per_tensor." }, "QuantizationPerTensor.kind.per_tensor": { "meaning": "One parameter applies to the whole tensor." }, "QuantizationPerAxis.kind": { "meaning": "The granularity. Always per_axis." }, "QuantizationPerAxis.kind.per_axis": { "meaning": "One parameter applies to each position on one axis." }, "QuantizationPerAxis.axis": { "meaning": "The quantized axis. A negative value counts from the end." }, "QuantizationBlocked.kind": { "meaning": "The granularity. Always blocked." }, "QuantizationBlocked.kind.blocked": { "meaning": "One parameter applies to each block on one axis." }, "QuantizationBlocked.axis": { "meaning": "The blocked axis. A negative value counts from the end." }, "QuantizationBlocked.block_size": { "meaning": "The number of adjacent values in a block." }, "StaticQuantizationParameters.kind": { "meaning": "The parameter form. Always static." }, "StaticQuantizationParameters.kind.static": { "meaning": "Scale and zero point come from stored tensors." }, "StaticQuantizationParameters.scale": { "meaning": "The customer-owned stored scale." }, "StaticQuantizationParameters.zero_point": { "meaning": "The stored or implicit affine zero point." }, "DynamicQuantizationParameters.kind": { "meaning": "The parameter form. Always dynamic." }, "DynamicQuantizationParameters.kind.dynamic": { "meaning": "Scale and zero point are computed for each call." }, "DynamicQuantizationParameters.rule": { "meaning": "The checked rule that computes scale and zero point." }, "DynamicQuantizationParameters.rule.onnx_dynamic_quantize_linear": { "meaning": "The standard ONNX DynamicQuantizeLinear rule." }, "DynamicQuantizationParameters.schema_version": { "meaning": "The exact resolved DynamicQuantizeLinear schema version." }, "Reference.math": { "meaning": "The mathematical meaning of the body, including the nondeterminism it permits, not any one runtime.", "was": "denotational" }, "Layout.any": { "meaning": "Inputs and outputs are logical values; memory layout is neither promised nor observed.", "was": "logical_values" }, "SideEffects.declared": { "meaning": "The function touches only the state it lists, in the modes it lists.", "was": "listed_resources_only" }, "Aliasing.default": { "meaning": "The relation for every pair of states not listed in pairs." }, "Aliasing.default.disjoint": { "meaning": "Unlisted pairs never share storage." }, "Aliasing.default.may_overlap": { "meaning": "Unlisted pairs may share storage. This is an explicit permission, not an unknown." }, "Aliasing.pairs": { "meaning": "Explicit pairs of states and their relation, overriding the default." }, "AliasPair.first": { "meaning": "The lesser state name of the pair, in ASCII order." }, "AliasPair.second": { "meaning": "The greater state name of the pair." }, "AliasPair.relation": { "meaning": "Whether the two states may share storage: disjoint or may_overlap." }, "AliasPair.relation.disjoint": { "meaning": "The two states never share storage." }, "AliasPair.relation.may_overlap": { "meaning": "The two states may share storage. This is an explicit permission, not an unknown." }, "Observe.outputs": { "meaning": "Only outputs, resulting state, effects, and termination count as observations.", "was": "interface (observations)" }, "GraphBody.kind": { "meaning": "Selects this body alternative. Always graph." }, "GraphBody.kind.graph": { "meaning": "A pure computation defined by an authoritative JSON graph." }, "GraphBody.graph": { "meaning": "The name of the json file holding the authoritative runlocal.graph document." }, "GraphBody.source": { "meaning": "An optional source artifact used to make the graph. It is provenance and does not define the computation." }, "GraphBody.inputs": { "meaning": "Function input names mapped to graph input names, where they differ." }, "GraphBody.outputs": { "meaning": "Function output names mapped to graph output names, where they differ." }, "GraphBody.weights": { "meaning": "Graph-input name overrides for weight ports whose names differ." }, "GraphBody.external_data": { "meaning": "External tensor-data locations the graph uses, each mapped to a file." }, "ExternalData.location": { "meaning": "An ONNX external-data location key. It is a lookup key, never a path." }, "ExternalData.file": { "meaning": "The name of the model file holding that location's bytes." }, "StepsBody.kind": { "meaning": "Selects this body alternative. Always steps." }, "StepsBody.kind.steps": { "meaning": "A body that composes other functions.", "was": "pipeline" }, "StepsBody.steps": { "meaning": "The steps by name. Map order carries no ordering.", "was": "calls" }, "StepsBody.outputs": { "meaning": "Where each output of the function comes from." }, "Step.call": { "meaning": "The function the step calls." }, "Step.inputs": { "meaning": "What each input of the called function receives.", "was": "arguments" }, "Step.weights": { "meaning": "Binds every weight port of the called function to a slot in weights or to a port of the enclosing function." }, "Step.weights.*": { "meaning": "Written-form shorthand: lifts every port of the called function that the step does not bind itself. Elaboration writes each binding and removes this entry, so it is never a name." }, "Step.after": { "meaning": "Steps that must complete before this one, beyond what the data edges imply." }, "ValueRef.input": { "meaning": "A value reference: an input of the enclosing function.", "was": "argument" }, "ValueRef.step": { "meaning": "A value reference: an output of another step, named by step and output.", "was": "result" }, "ValueRef.output": { "meaning": "Inside a step value reference: which output of that step." }, "ValueRef.constant": { "meaning": "A value reference naming an entry in constants." }, "BlackBox.kind": { "meaning": "Selects this body alternative. Always black_box." }, "BlackBox.kind.black_box": { "meaning": "A fixed implementation on the customer's machine that Runlocal never sees or runs. Every call to it is preserved.", "was": "opaque" }, "BlackBox.binding": { "meaning": "A name for the implementation on the customer's machine.", "was": "local_binding" }, "BlackBox.version": { "meaning": "The version of that implementation." }, "BlackBox.effects": { "meaning": "The effects of the opaque implementation. Functional bodies have no effect record." }, "BlackBox.effects.side_effects": { "meaning": "What the opaque implementation may touch beyond inputs and outputs: declared, or {unknown}.", "was": "effect_scope" }, "BlackBox.effects.aliasing": { "meaning": "Whether its session slots may share storage: a default and explicit pairs, or {unknown}.", "was": "resource_aliases" }, "Missing.kind": { "meaning": "Selects this body alternative. Always missing." }, "Missing.kind.missing": { "meaning": "No body is supplied yet. Names at least one fact-purpose unknown knowledge entry.", "was": "unresolved" }, "Missing.unknowns": { "meaning": "Which fact-purpose unknown knowledge entries explain the gap.", "was": "requirements" }, "Entrypoint.function": { "meaning": "The function the entrypoint calls." }, "Entrypoint.state": { "meaning": "Which slot in state each state of the function binds to.", "was": "resources" }, "Entrypoint.note": { "meaning": "Free text for people reviewing the entrypoint. Notes count toward the revision digest and never toward the contract or example digests, so they cannot change what is asked." }, "WeightSlot.domain": { "meaning": "The value domain that this shared weight slot guarantees.", "was": "values" }, "WeightSlot.type": { "meaning": "The slot's tensor type, such as float16[N,512]." }, "WeightSlot.private": { "meaning": "true when the slot's values never appear in the request and no transformation folds them.", "was": "disclosure: local_only" }, "WeightSlot.access": { "meaning": "Weights are read-only." }, "WeightSlot.access.read": { "meaning": "Calls read the weight and never change its values." }, "WeightSlot.supplied": { "meaning": "When the slot's value is bound: at_runtime or prepared_locally.", "was": "binding" }, "WeightSlot.supplied.at_runtime": { "meaning": "Bound when the model runs.", "was": "runtime" }, "WeightSlot.supplied.prepared_locally": { "meaning": "Prepared on the customer's machine before use; no packed format is implied.", "was": "local_preparation" }, "WeightSlot.lives": { "meaning": "How long the slot's value is fixed: per_call or per_session.", "was": "lifetime" }, "WeightSlot.lives.per_call": { "meaning": "The value is fixed during one call.", "was": "invocation" }, "WeightSlot.lives.per_session": { "meaning": "The value is fixed until the customer-local session ends.", "was": "session" }, "WeightSlot.constraints": { "meaning": "Conditions on the slot's value, written as text over the single term value.", "was": "domain" }, "WeightSlot.note": { "meaning": "Free text for people reviewing the weight slot. Notes count toward the revision digest and never toward the contract or example digests, so they cannot change what is asked." }, "TiedPair.first": { "meaning": "A weight port or slot name." }, "TiedPair.second": { "meaning": "Another weight holding the same values as the first." }, "StateSlot.private": { "meaning": "Whether actual values must stay on the client's machine." }, "StateSlot.domain": { "meaning": "The value domain: restrictions that every value supplied to this slot must satisfy.", "was": "values" }, "StateSlot.lives": { "meaning": "How long a state instance lives: per_call or per_session.", "was": "lifetime" }, "StateSlot.lives.per_call": { "meaning": "The instance lives for one call.", "was": "invocation" }, "StateSlot.lives.per_session": { "meaning": "The instance persists across calls in one session.", "was": "session" }, "StateSlot.initial": { "meaning": "How the state starts: no value, a constant, or an extension. No state is implicitly zeroed." }, "StateSlot.reset": { "meaning": "How the state is reset: new_instance, reinitialize, or an extension. Never an implicit event between benchmark runs." }, "StateSlot.reset.new_instance": { "meaning": "Reset only by ending the state instance and creating a new one." }, "StateSlot.reset.reinitialize": { "meaning": "Apply the initializer again once dependent calls complete." }, "StateSlot.note": { "meaning": "Free text for people reviewing the state slot. Notes count toward the revision digest and never toward the contract or example digests, so they cannot change what is asked." }, "Constant.type": { "meaning": "The constant's exact tensor type." }, "Constant.source": { "meaning": "A model file or an extension that holds the constant's complete value.", "was": "file" }, "TorchEnvironment.kind": { "meaning": "The environment kind. Always torch." }, "TorchEnvironment.kind.torch": { "meaning": "A pinned Python environment that contains Torch." }, "TorchEnvironment.python": { "meaning": "The exact Python version." }, "TorchEnvironment.packages": { "meaning": "Exact installed package versions. This map includes torch." }, "OnnxOperator.kind": { "meaning": "The operator system. Always onnx." }, "OnnxOperator.kind.onnx": { "meaning": "An operator whose meaning comes from ONNX, a local function, an extension, or an explicit unknown." }, "OnnxOperator.domain": { "meaning": "The operator domain as the graphs spell it; empty for the standard operators." }, "OnnxOperator.op_type": { "meaning": "The operator type name." }, "OnnxOperator.overload": { "meaning": "The operator overload, when the model uses one." }, "OnnxOperator.opset": { "meaning": "The opset version the graphs import for the operator's domain.", "was": "opset_version" }, "OnnxOperator.semantics": { "meaning": "What the operator computes: onnx, local_function, an operator extension, or {unknown}. Never Identity by default." }, "OnnxOperator.uses": { "meaning": "How many nodes apply the operator across every graph, subgraphs and local function bodies included." }, "OnnxOperator.note": { "meaning": "Free text for people reviewing the operator. Notes count toward the revision digest and never toward the contract or example digests, so they cannot change what is asked." }, "TorchOperator.kind": { "meaning": "The operator system. Always torch." }, "TorchOperator.kind.torch": { "meaning": "An operator whose meaning comes from pinned Torch API or Python source. The entry is an identity. Each graph node states its own arguments." }, "TorchOperator.environment": { "meaning": "The pinned Torch environment that defines this operator's public API and dependencies." }, "TorchOperator.definition": { "meaning": "The public API, module implementation, or inline source that defines this operator." }, "TorchOperator.uses": { "meaning": "How many graph nodes name this operator entry." }, "TorchOperator.note": { "meaning": "Free text for people reviewing the operator. Notes count toward the revision digest and never toward the contract or example digests, so they cannot change what is asked." }, "TorchApiDefinition.kind": { "meaning": "The definition kind. Always api." }, "TorchApiDefinition.kind.api": { "meaning": "A public callable from the pinned Torch package." }, "TorchApiDefinition.callable": { "meaning": "The fully qualified public Torch callable." }, "TorchSourceDefinition.kind": { "meaning": "The definition kind. Always source." }, "TorchSourceDefinition.kind.source": { "meaning": "An inline top-level Python callable." }, "TorchSourceDefinition.callable": { "meaning": "The top-level Python callable name." }, "TorchSourceDefinition.code": { "meaning": "The authoritative UTF-8 Python source. Validation does not parse, import, or run it." }, "TorchModuleDefinition.kind": { "meaning": "The definition kind. Always module." }, "TorchModuleDefinition.kind.module": { "meaning": "An eval-only torch.nn.Module instance." }, "TorchModuleDefinition.implementation": { "meaning": "The public Torch class or inline Python class used by the module." }, "TorchModuleDefinition.constructor": { "meaning": "Fixed constructor arguments by parameter name. A JSON array states a Python tuple or list." }, "TorchModuleDefinition.training": { "meaning": "Whether the module uses training mode. Torch graph modules require false." }, "TorchModuleDefinition.parameters": { "meaning": "The qualified module parameter names. Each node that applies the module supplies each one." }, "TorchModuleDefinition.buffers": { "meaning": "The qualified persistent module buffer names. Each node that applies the module supplies each one." }, "OperatorSemantics.onnx": { "meaning": "The ONNX definition of the operator at the entry's opset; only for a standard domain." }, "OperatorSemantics.local_function": { "meaning": "The model's own local function with the entry's domain, op_type, and overload defines the operator." }, "Target.where": { "meaning": "Which calls the target applies to: every call of a function, or one call site reached from an entrypoint.", "was": "scope" }, "Target.select": { "meaning": "Which part of a body the target selects: body, steps, nodes, or an extension.", "was": "selection" }, "Target.wants": { "meaning": "The kinds of work of the published work table that the target asks for. A want that the request does not support rejects an upload." }, "Target.note": { "meaning": "Free text for people reviewing the target. Notes count toward the revision digest and never toward the contract or example digests, so they cannot change what is asked." }, "Where.function": { "meaning": "Every call of this function." }, "Where.entrypoint": { "meaning": "The entrypoint a call site is reached from." }, "Where.path": { "meaning": "Step names followed from the entrypoint's function to a call site. Empty means the entrypoint's own body.", "was": "call_path" }, "Select.body": { "meaning": "The whole body of the selected function." }, "Select.steps": { "meaning": "A convex set of steps in a steps body.", "was": "pipeline_cut" }, "Select.nodes": { "meaning": "A convex set of graph nodes, by node name or graph path.", "was": "onnx_cut" }, "Example.dimensions": { "meaning": "Exact extents or narrower ranges for the entrypoint function's declared dimensions. These restrict calls; counts only record measurements." }, "Example.entrypoint": { "meaning": "Which entrypoint the example calls." }, "Example.inputs": { "meaning": "What each input of the entrypoint's function is bound to." }, "Example.weights": { "meaning": "The source of each weight, keyed by an entrypoint port name, /functions//weights/, /weights/, the group key * for every entrypoint port with no source of its own, or the group key /weights/* for every program slot with no source of its own.", "was": "parameters" }, "Example.weights.*": { "meaning": "The source for every entrypoint weight port that has no source of its own." }, "Example.weights./weights/*": { "meaning": "The source for every program slot that the example reaches and that has no source of its own." }, "Example.state": { "meaning": "What each state slot is bound to.", "was": "resources" }, "Example.outputs": { "meaning": "What the source produced for each output on the values of this example: a reference that the service can compare the computation against. Absent means no reference." }, "Example.constraints": { "meaning": "Conditions written as text over shapes that hold for every run the example stands for, beyond the function's own.", "was": "domain" }, "Example.counts": { "meaning": "Quantities measured on the supplied samples, keyed by a term such as N or points.shape[0]. Measurements, never promises; a count never encodes a relation.", "was": "census" }, "Example.note": { "meaning": "Free text for people reviewing the example. Notes count toward the revision digest and never toward the contract or example digests, so they cannot change what is asked." }, "KnowledgePurpose.fact": { "meaning": "Records a fact or an open question about a fact." }, "KnowledgePurpose.source_equivalence": { "meaning": "Assesses whether the request matches the source behavior." }, "KnowledgePurpose.replacement_equivalence": { "meaning": "Assesses whether a replacement matches the request contract." }, "KnowledgePurpose.baseline_fidelity": { "meaning": "Assesses this model against a named baseline contract." }, "KnowledgePurpose.other": { "meaning": "Records another stated question or claim." }, "UnknownKnowledge.kind": { "meaning": "How this entry was established. Always unknown." }, "UnknownKnowledge.kind.unknown": { "meaning": "A stated question that available knowledge does not answer." }, "UnknownKnowledge.purpose": { "meaning": "Why this question is recorded." }, "UnknownKnowledge.subjects": { "meaning": "The nonempty ordered set of document pointers this question covers." }, "UnknownKnowledge.depends_on": { "meaning": "Knowledge entries that this question relies on. Always acyclic." }, "UnknownKnowledge.question": { "meaning": "The question that remains unanswered." }, "UnknownKnowledge.why": { "meaning": "Why the answer is unknown." }, "UnknownKnowledge.why.not_checked": { "meaning": "Nobody checked it yet.", "was": "not_inspected" }, "UnknownKnowledge.why.not_seen": { "meaning": "It was sought but not seen.", "was": "not_observed" }, "UnknownKnowledge.why.private": { "meaning": "The customer withholds the fact.", "was": "withheld" }, "UnknownKnowledge.why.cannot_tell": { "meaning": "Available information cannot answer it.", "was": "not_derivable" }, "UnknownKnowledge.note": { "meaning": "Free text for people reviewing the question. Notes count toward the revision digest and never toward the contract or example digests, so they cannot change what is asked." }, "EvidenceKnowledge.kind": { "meaning": "The method: claimed, observed, tested, or proved. It is not a confidence level." }, "EvidenceKnowledge.kind.claimed": { "meaning": "A named tool asserts the claim." }, "EvidenceKnowledge.kind.observed": { "meaning": "The claim comes from recorded runs or inspected files." }, "EvidenceKnowledge.kind.tested": { "meaning": "A named procedure checked a finite set of cases." }, "EvidenceKnowledge.kind.proved": { "meaning": "A named proof procedure established the claim under its assumptions." }, "EvidenceKnowledge.purpose": { "meaning": "Why this evidence is recorded." }, "EvidenceKnowledge.subjects": { "meaning": "The nonempty ordered set of document pointers this evidence covers." }, "EvidenceKnowledge.depends_on": { "meaning": "Knowledge entries that this evidence relies on. Always acyclic." }, "EvidenceKnowledge.outcome": { "meaning": "Whether the evidence supports, refutes, or cannot decide the claim." }, "EvidenceKnowledge.outcome.supports": { "meaning": "The evidence supports the claim." }, "EvidenceKnowledge.outcome.refutes": { "meaning": "The evidence refutes the claim." }, "EvidenceKnowledge.outcome.inconclusive": { "meaning": "The evidence does not decide the claim." }, "EvidenceKnowledge.tool": { "meaning": "The tool that produced the evidence." }, "EvidenceKnowledge.claim": { "meaning": "The proposition that the evidence assesses." }, "EvidenceKnowledge.procedure": { "meaning": "How the assessment was done." }, "EvidenceKnowledge.contract_digest": { "meaning": "The contract digest of the exact computation that this evidence assessed, or null.", "was": "content_digest" }, "EvidenceKnowledge.cases": { "meaning": "How many cases a tested entry ran." }, "EvidenceKnowledge.passed": { "meaning": "How many tested cases passed." }, "EvidenceKnowledge.tolerance": { "meaning": "The accepted difference in a numerical comparison, as text with its metric. In a request it records a comparison. A response can state a tolerance for a replacement." }, "EvidenceKnowledge.artifacts": { "meaning": "Evidence or sample files that support the assessment." }, "EvidenceKnowledge.assumptions": { "meaning": "Assumptions used by the assessment. They do not narrow accepted inputs." }, "EvidenceKnowledge.fidelity": { "meaning": "Structured baseline fidelity evidence, or null." }, "EvidenceKnowledge.confidence": { "meaning": "A subjective estimate from 0 through 1 with a reason, or null." }, "EvidenceKnowledge.note": { "meaning": "Free text for people reviewing the evidence. Notes count toward the revision digest and never toward the contract or example digests, so they cannot change what is asked." }, "FidelityMetric.name": { "meaning": "The metric name." }, "FidelityMetric.value": { "meaning": "The measured value." }, "FidelityMetric.comparison": { "meaning": "How the measured value is compared with its limit." }, "FidelityMetric.comparison.at_least": { "meaning": "The value must be at least the limit." }, "FidelityMetric.comparison.at_most": { "meaning": "The value must be at most the limit." }, "FidelityMetric.limit": { "meaning": "The acceptance limit." }, "FidelityMetric.unit": { "meaning": "The metric unit, or an empty string for a unitless value." }, "FidelityInterface.current_entrypoint": { "meaning": "The current request entrypoint." }, "FidelityInterface.baseline_entrypoint": { "meaning": "The matching baseline entrypoint." }, "FidelityInterface.inputs": { "meaning": "The public input types shared by both entrypoints." }, "FidelityInterface.outputs": { "meaning": "The public output types shared by both entrypoints." }, "FidelityEvidence.current_contract": { "meaning": "The quantized model contract digest." }, "FidelityEvidence.baseline_contract": { "meaning": "The baseline model contract digest." }, "FidelityEvidence.current_checkpoint": { "meaning": "The local quantized checkpoint identifier." }, "FidelityEvidence.baseline_checkpoint": { "meaning": "The local baseline checkpoint identifier." }, "FidelityEvidence.evaluation_data": { "meaning": "The immutable evaluation data identifier." }, "FidelityEvidence.runtime": { "meaning": "The runtime used for both sides of the comparison." }, "FidelityEvidence.runtime.name": { "meaning": "The runtime name." }, "FidelityEvidence.runtime.version": { "meaning": "The exact runtime version." }, "FidelityEvidence.runtime.device": { "meaning": "The device and relevant execution settings." }, "FidelityEvidence.interfaces": { "meaning": "The compared public entrypoints." }, "FidelityEvidence.metrics": { "meaning": "Measured fidelity results and their limits." }, "Tool.name": { "meaning": "The name of the tool that produced the evidence." }, "Tool.version": { "meaning": "The version of that tool." }, "Confidence.value": { "meaning": "The subjective estimate from 0 through 1. It is not calibrated or server-endorsed." }, "Confidence.reason": { "meaning": "Why the submitting tool gave this estimate." }, "ExtensionDefinition.slot": { "meaning": "Which part of the document the extension may fill." }, "ExtensionDefinition.slot.body": { "meaning": "A function's body." }, "ExtensionDefinition.slot.operator": { "meaning": "The meaning of a custom operator." }, "ExtensionDefinition.slot.type": { "meaning": "The type of an input or output that is not a tensor." }, "ExtensionDefinition.slot.constant": { "meaning": "An entry in constants." }, "ExtensionDefinition.slot.constraint": { "meaning": "Constraints." }, "ExtensionDefinition.slot.layout": { "meaning": "The layout term of a contract." }, "ExtensionDefinition.slot.state": { "meaning": "How a state starts or is reset." }, "ExtensionDefinition.slot.numerics": { "meaning": "The numerics term of a contract." }, "ExtensionDefinition.slot.quantization": { "meaning": "Physical storage for logical tensors in a quantization overlay." }, "ExtensionDefinition.slot.reference": { "meaning": "The reference term of a contract." }, "ExtensionDefinition.slot.observe": { "meaning": "The observe term of a contract." }, "ExtensionDefinition.slot.target": { "meaning": "What a target under optimize selects.", "was": "region" }, "ExtensionDefinition.name": { "meaning": "The extension's name. A name alone never identifies an extension." }, "ExtensionDefinition.version": { "meaning": "The extension's version." }, "ExtensionDefinition.schema": { "meaning": "A json file holding the JSON Schema that the extension's payloads must satisfy." }, "ExtensionDefinition.specification": { "meaning": "A file holding the extension's specification. Data, not permission to run code." }, "ExtensionDefinition.depends_on": { "meaning": "Extensions this one builds on. Always acyclic." }, "ExtensionDefinition.note": { "meaning": "Free text for people reviewing the extension. Notes count toward the revision digest and never toward the contract or example digests, so they cannot change what is asked." }, "Extension.kind": { "meaning": "Marks a value as the use of an extension. Always extension." }, "Extension.kind.extension": { "meaning": "A payload that uses an extension in one slot." }, "Extension.extension": { "meaning": "The entry in extensions that defines the payload." }, "Extension.payload": { "meaning": "The inline JSON of the extension use, satisfying its schema." } } }