Carl Niklas Rydberg 4dae7a32d2 Add PEL tier1 specifications

2025-12-20 12:35:10 +01:00

27 KiB

Raw Blame History

PEL/PROGRAM-DAG-DESC/1 — Scheme Descriptor for DAG Program Scheme

Status: Approved Owner: Niklas Rydberg Version: 0.1.6 SoT: Yes Last Updated: 2025-11-16 Linked Phase Pack: N/A Tags: [composition, registry]

Document ID: PEL/PROGRAM-DAG-DESC/1 Layer: L1 Scheme Descriptor (binds PEL scheme to ASL values)

Depends on (normative):

ASL/1-CORE v0.4.x — Artifact substrate (Artifact, TypeTag, Reference, EncodingProfileId)
ENC/ASL1-CORE v1.0.x — canonical encoding profile (ASL_ENC_CORE_V1)
PEL/1-CORE v0.3.x — primitive execution layer (schemes and Exec_s)
PEL/PROGRAM-DAG/1 v0.3.x — DAG program scheme (Program, Node, Exec_DAG, symbolic SchemeRef_DAG_1)
ENC/PEL-PROGRAM-DAG/1 v0.2.x — canonical encoding for DAG programs (Program Artifacts, profile ID PEL_ENC_PROGRAM_DAG_V1)

References (informative):

HASH/ASL1 v0.2.x — ASL1 hash family (HashId assignments, HASH-ASL1-256)
SUBSTRATE/STACK-OVERVIEW v0.3.x — stack layering and kernel invariants
ENC/PEL-TRACE-DAG/1 v0.1.x — canonical encoding for DAG traces (Trace Artifacts)
OPREG/PEL1-KERNEL and related param profiles — operation registry for DAG ops (context only)

License

Except where otherwise noted, this document (text and diagrams) is licensed under the Creative Commons Attribution 4.0 International License (CC BY 4.0).

The identifier registries and mapping tables (e.g. TypeTag IDs, HashId assignments, EdgeTypeId tables) are additionally made available under CC0 1.0 Universal (CC0) to enable unrestricted reuse in implementations and derivative specifications.

Code examples in this document are provided under the Apache License 2.0 unless explicitly stated otherwise. Test vectors, where present, are dedicated to the public domain under CC0 1.0.

0. Overview

PEL/PROGRAM-DAG/1 defines the DAG program scheme for PEL/1-CORE and refers to its scheme identifier symbolically as SchemeRef_DAG_1.

PEL/PROGRAM-DAG-DESC/1 defines:

the logical descriptor value for the DAG scheme,
its realization as a concrete ASL/1 Artifact (the descriptor Artifact), and
how engines derive and recognize SchemeRef_DAG_1 as the scheme’s SchemeRef.

In particular, this document:

binds the DAG scheme semantics (Exec_DAG) to a specific SchemeRef value;
specifies the descriptor’s TypeTag and internal structure;
specifies how SchemeRef_DAG_1 is derived from the descriptor Artifact under ASL_ENC_CORE_V1 and a chosen hash algorithm; and
fixes a canonical SchemeRef_DAG_1 for the Amduat 2.0 baseline profile using HASH-ASL1-256 (HashId = 0x0001),

without introducing dependencies on stores, TGK, certificates, facts, or overlays.

1. Scope & Layering

1.1 Purpose

This specification defines:

The logical structure of the DAG scheme descriptor value (DagSchemeDescriptor).
The descriptor Artifact that carries this value:
- its type_tag (a “PEL scheme descriptor” TypeTag), and
- its canonical bytes layout.
The derivation of SchemeRef_DAG_1 as a Reference to that descriptor Artifact.
The binding between SchemeRef_DAG_1 and the DAG scheme defined in PEL/PROGRAM-DAG/1.

It does not redefine:

DAG program semantics or structure (Program, Node, Exec_DAG),
Program or trace encodings (ENC/PEL-PROGRAM-DAG/1, ENC/PEL-TRACE-DAG/1),
hash algorithms or HashId (HASH/ASL1),
store, graph, certification, or provenance behavior.

1.2 Layering constraints

In line with SUBSTRATE/STACK-OVERVIEW:

PEL/PROGRAM-DAG-DESC/1 is a scheme descriptor:
- it binds a PEL scheme (PEL/PROGRAM-DAG/1) to a specific ASL/1 Reference; and
- it describes how engines recognize and interpret that scheme.
It MUST NOT introduce dependencies on:
- stores (ASL/1-STORE),
- graph kernels or graph stores (TGK/1-CORE, TGK/STORE/1),
- certification, evidence, facts, or overlays (CIL/1, FER/1, FCT/1, OI/1).
It MAY refer informatively to:
- canonical trace encodings (ENC/PEL-TRACE-DAG/1),
- operation registries and parameter profiles (OPREG/PEL1-KERNEL, etc.),

but MUST NOT depend on them for its core semantics.

2. Dependencies, Terminology & Conventions

RFC 2119 terms (MUST, SHOULD, MAY, etc.) are normative.

2.1 From ASL/1-CORE

Artifact {
  bytes:    OctetString
  type_tag: optional TypeTag
}

TypeTag {
  tag_id: uint32
}

Reference {
  hash_id: HashId
  digest:  OctetString
}

HashId            = uint16
EncodingProfileId = uint16

This spec treats:

Artifact as the unit of identity and content,
TypeTag as the typing hint for Artifact.bytes,
Reference as the content address for Artifacts, and
EncodingProfileId as the identifier of encoding profiles (e.g. ASL_ENC_CORE_V1, PEL_ENC_PROGRAM_DAG_V1).

2.2 From ENC/ASL1-CORE v1

ENC/ASL1-CORE v1 defines:

ArtifactBytes = encode_artifact_core_v1(Artifact) — canonical encoding for Artifacts.
ReferenceBytes = encode_reference_core_v1(Reference) — canonical encoding for References.

It also instantiates the generic ASL rule:

ArtifactBytes = encode_P(A)
digest        = H(ArtifactBytes)
Reference     = { hash_id = HID, digest = digest }

for P = ASL_ENC_CORE_V1 and any hash algorithm H with HashId = HID.

2.3 From PEL/1-CORE and PEL/PROGRAM-DAG/1

From PEL/1-CORE:

SchemeRef = Reference

Exec_s :
  (program: Artifact, inputs: list<Artifact>, params: optional Artifact)
    -> (outputs: list<Artifact>, result: ExecutionResultValue)

From PEL/PROGRAM-DAG/1:

The DAG scheme is a concrete scheme over PEL/1-CORE:

Exec_DAG :
  (program: Artifact, inputs: list<Artifact>, params: optional Artifact)
    -> (outputs: list<Artifact>, result: ExecutionResultValue)

This scheme is identified symbolically as SchemeRef_DAG_1, with:
```
SchemeRef = SchemeRef_DAG_1
Exec_s    = Exec_DAG
```

PEL/PROGRAM-DAG-DESC/1 makes this symbolic SchemeRef_DAG_1 concrete.

2.4 Conventions

Unless stated otherwise:

Integers:
- u8 — 1 byte, unsigned.
- u16 — 2 bytes, unsigned, big-endian.
- u32 — 4 bytes, unsigned, big-endian.
Utf8String is encoded as:
```
Utf8String =
  length (u32)
  bytes[0..length-1]
```
where:
- length is the number of bytes,
- bytes MUST be well-formed UTF-8,
- there is no terminator or padding.
Embedded Reference values use a length-prefixed wrapper over canonical ReferenceBytes from ENC/ASL1-CORE v1:
```
EncodedRef =
  ref_len   (u32)
  ref_bytes (byte[0..ref_len-1])  // canonical ReferenceBytes
```
where:
- ref_bytes MUST be the canonical ReferenceBytes for some Reference value under ENC/ASL1-CORE v1,
- ref_len MUST be the exact length of ref_bytes (MUST be ≥ 2).
Decoders MUST:
- treat ref_len < 2 as an encoding error, and
- decode ref_bytes using decode_reference_core_v1. Any failure in that decoding (including, when HASH/ASL1 is implemented, a digest-length mismatch for a known hash_id) MUST be treated as an encoding error for DagSchemeDescriptorBytes.
Optional Reference fields use:
```
OptionalEncodedRef =
  has_ref (u8)
  [ EncodedRef ]   // only if has_ref == 0x01
```
with:
- has_ref = 0x00 → no value present (no EncodedRef follows),
- has_ref = 0x01 → exactly one EncodedRef follows,
- other has_ref values are encoding errors.

3. Descriptor Logical Model

3.1 DagSchemeDescriptor (logical)

At the logical level, the DAG scheme descriptor is modeled as:

DagSchemeDescriptor {
  pel1_version:        uint16

  scheme_name:         String          // logical identifier, e.g. "PEL/PROGRAM-DAG/1"

  program_type_tag:    TypeTag         // TYPE_TAG_PEL_PROGRAM_DAG_1
  program_enc_profile: EncodingProfileId
                                        // PEL_ENC_PROGRAM_DAG_V1 (0x0101)

  trace_profile_ref:   optional Reference
                                        // to a trace-profile descriptor (e.g. PEL/TRACE-DAG-DESC/1)
  opreg_ref:           optional Reference
                                        // to a canonical operation-registry descriptor (e.g. OPREG/PEL1-KERNEL)
}

This structure is logical; the descriptor’s concrete bytes are defined in §4.

The program_type_tag / program_enc_profile pair tells engines how to interpret Program Artifacts for this scheme:

program_type_tag ⇒ which TypeTag marks an Artifact as a DAG Program for this scheme;
program_enc_profile ⇒ which Program encoding profile (specifically, PEL_ENC_PROGRAM_DAG_V1 from ENC/PEL-PROGRAM-DAG/1) to use when decoding/encoding those Artifacts.

This pair is independent from the ASL-level encoding profile used for the descriptor Artifact itself, which is always ASL_ENC_CORE_V1 when deriving SchemeRef_DAG_1 (§5.2).

This document does not require engines to inspect all fields at runtime. In particular:

engines that already know SchemeRef_DAG_1, TYPE_TAG_PEL_PROGRAM_DAG_1, and PEL_ENC_PROGRAM_DAG_V1 MAY treat the descriptor as metadata; and
the canonical binding to PEL/PROGRAM-DAG/1 is via SchemeRef_DAG_1 and the program_type_tag / program_enc_profile pair, not via scheme_name or the optional references.

3.2 Field semantics & invariants

For the Amduat 2.0 baseline DAG scheme descriptor (the one used to define SchemeRef_DAG_1) the following invariants apply:

pel1_version:
- MUST be 1.
- Indicates the descriptor is written against PEL/1-CORE version 1 semantics.
- Future PEL versions MAY introduce new descriptor formats, but MUST NOT change the meaning of pel1_version = 1.
scheme_name:
- MUST be the UTF-8 string "PEL/PROGRAM-DAG/1", compared byte-for-byte and case-sensitively.
- Serves as a human-readable identifier and sanity check.
- Changing scheme_name (while keeping other fields identical) changes the descriptor value and therefore its Reference.
program_type_tag:
- MUST equal the TypeTag used for DAG Program Artifacts, symbolically:
```
program_type_tag = TYPE_TAG_PEL_PROGRAM_DAG_1
```
- The concrete numeric tag_id is assigned by the TypeTag registry and is not restated here.
program_enc_profile:
- MUST be the EncodingProfileId of ENC/PEL-PROGRAM-DAG/1, symbolically:
```
program_enc_profile = PEL_ENC_PROGRAM_DAG_V1
```
- In the current encoding profile, this is 0x0101, but this spec treats it symbolically; the numeric value comes from the encoding profile registry.
trace_profile_ref:
- Optionally points at a descriptor Artifact that defines a canonical trace profile for this scheme (e.g. a future PEL/TRACE-DAG-DESC/1).
- For the canonical Amduat 2.0 baseline descriptor used to define SchemeRef_DAG_1, this field is absent:
```
trace_profile_ref = None
```
- Future companion descriptors MAY set this field, but those will not be the descriptor used for SchemeRef_DAG_1.
opreg_ref:
- Optionally points at a descriptor Artifact for the canonical operation registry for this scheme (e.g. OPREG/PEL1-KERNEL).
- For the canonical Amduat 2.0 baseline descriptor used to define SchemeRef_DAG_1, this field is absent:
```
opreg_ref = None
```
- As with trace_profile_ref, future descriptors MAY set this field, but those will define distinct SchemeRef values, not SchemeRef_DAG_1.

3.3 Canonical descriptor value for the DAG scheme

Let:

DagSchemeDescriptor_DAG_1 : DagSchemeDescriptor

denote the unique logical descriptor value that satisfies:

DagSchemeDescriptor_DAG_1 {
  pel1_version        = 1

  scheme_name         = "PEL/PROGRAM-DAG/1"

  program_type_tag    = TYPE_TAG_PEL_PROGRAM_DAG_1
  program_enc_profile = PEL_ENC_PROGRAM_DAG_V1

  trace_profile_ref   = None
  opreg_ref           = None
}

All Amduat 2.0 baseline components MUST agree on this logical value as “the” DAG scheme descriptor for binding PEL/PROGRAM-DAG/1 to a SchemeRef.

Any descriptor with different logical contents (including differing optional fields) describes either:

a different scheme, or
a different profile or version of the DAG scheme,

and MUST NOT be used to derive SchemeRef_DAG_1.

Because the descriptor is carried in an ASL/1 Artifact and scheme references are content-addressed, any change to this descriptor (even in optional fields) yields a different Reference; SchemeRef_DAG_1 is therefore permanently tied to exactly this v1 descriptor.

4. Descriptor Artifact & Encoding

4.1 Descriptor TypeTag

The DAG scheme descriptor is carried by an ASL/1 Artifact with a dedicated TypeTag:

TYPE_TAG_PEL_SCHEME_DESC_1 : TypeTag

TYPE_TAG_PEL_SCHEME_DESC_1 is a symbolic constant for a TypeTag.tag_id assigned by the global TypeTag registry.
This TypeTag MUST be used for the DAG scheme descriptor Artifact defined in this document.
Other PEL scheme descriptors MAY reuse this TypeTag and the encoding in §4.2, but such reuse MUST be specified in their own descriptor documents.

The descriptor Artifact for the DAG scheme has the shape:

DagSchemeDescriptorArtifact_DAG_1 : Artifact {
  type_tag = TYPE_TAG_PEL_SCHEME_DESC_1
  bytes    = DagSchemeDescriptorBytes_DAG_1
}

where DagSchemeDescriptorBytes_DAG_1 is the canonical encoding of DagSchemeDescriptor_DAG_1 defined in §4.2.

This Artifact itself is encoded to ArtifactBytes using ASL_ENC_CORE_V1 when deriving SchemeRef_DAG_1 (§5.2). That use of ASL_ENC_CORE_V1 is independent of the program_enc_profile field, which is about how Program Artifacts are encoded.

4.2 Descriptor encoding layout

The descriptor value DagSchemeDescriptor is encoded into DagSchemeDescriptorBytes using a small, fixed layout over primitive types:

DagSchemeDescriptorBytes ::
  pel1_version        (u16)

  scheme_name         (Utf8String)

  program_type_tag    (u32)   // TypeTag.tag_id
  program_enc_profile (u16)   // EncodingProfileId

  has_trace_profile   (u8)
  [ trace_profile_ref (EncodedRef) ]   // if has_trace_profile == 0x01

  has_opreg_ref       (u8)
  [ opreg_ref         (EncodedRef) ]   // if has_opreg_ref == 0x01

Constraints:

pel1_version MUST be 1 for descriptors governed by this document.
scheme_name MUST be encoded as a Utf8String (§2.4).
program_type_tag encodes TypeTag.tag_id for TYPE_TAG_PEL_PROGRAM_DAG_1.
program_enc_profile encodes the EncodingProfileId for PEL_ENC_PROGRAM_DAG_V1 as defined in ENC/PEL-PROGRAM-DAG/1.
has_trace_profile:
- 0x00 → trace_profile_ref is absent; no bytes for it follow.
- 0x01 → trace_profile_ref is present and encoded as EncodedRef.
- Any other value is an encoding error.
has_opreg_ref:
- 0x00 → opreg_ref is absent.
- 0x01 → opreg_ref is present and encoded as EncodedRef.
- Any other value is an encoding error.

For the canonical baseline descriptor:

pel1_version        = 1
scheme_name         = "PEL/PROGRAM-DAG/1"
program_type_tag    = TYPE_TAG_PEL_PROGRAM_DAG_1.tag_id
program_enc_profile = PEL_ENC_PROGRAM_DAG_V1
has_trace_profile   = 0x00
has_opreg_ref       = 0x00

The resulting bytes are DagSchemeDescriptorBytes_DAG_1.

4.3 Encoding and decoding (normative)

Let:

encode_dag_scheme_descriptor_v1 : DagSchemeDescriptor -> OctetString
decode_dag_scheme_descriptor_v1 : OctetString -> DagSchemeDescriptor | error

be the encoding and decoding functions for this profile.

Encoding:

Given a DagSchemeDescriptor value:

Emit pel1_version (u16).
Emit scheme_name as Utf8String.
Emit program_type_tag.tag_id as u32.
Emit program_enc_profile as u16.
For trace_profile_ref:
- If absent:
  - emit has_trace_profile = 0x00.
- If present:
  - emit has_trace_profile = 0x01,
  - emit trace_profile_ref as EncodedRef (u32 length + ReferenceBytes).
For opreg_ref:
- If absent:
  - emit has_opreg_ref = 0x00.
- If present:
  - emit has_opreg_ref = 0x01,
  - emit opreg_ref as EncodedRef.

The concatenation of all emitted bytes is DagSchemeDescriptorBytes.

Decoding:

Given an OctetString known to contain exactly one DagSchemeDescriptorBytes value:

Read pel1_version (u16).
- If pel1_version != 1, decoders that only implement this version MUST treat this as an encoding error. Future decoders MAY support additional versions but MUST NOT reinterpret pel1_version = 1.
Read scheme_name as Utf8String and validate UTF-8.
Read program_type_tag (u32) and construct TypeTag { tag_id = program_type_tag }.
Read program_enc_profile (u16).
Read has_trace_profile (u8):
- 0x00 → trace_profile_ref = None.
- 0x01 → read trace_profile_ref as EncodedRef and decode to Reference.
- other values → encoding error.
Read has_opreg_ref (u8):
- 0x00 → opreg_ref = None.
- 0x01 → read opreg_ref as EncodedRef and decode to Reference.
- other values → encoding error.
If there are trailing bytes after successfully decoding all fields, decoders MAY treat this as an encoding error in contexts expecting a single DagSchemeDescriptorBytes value.

The mapping between DagSchemeDescriptor and DagSchemeDescriptorBytes defined here is the only encoding/decoding pair permitted by this profile.

4.4 Canonicality and injectivity

The mapping:

DagSchemeDescriptor -> DagSchemeDescriptorBytes

defined above MUST be:

Injective — distinct logical descriptor values MUST produce distinct byte strings.
Stable — the same logical descriptor MUST always encode to the same bytes across implementations and time.
Streaming-friendly — encoders and decoders MUST be implementable in a single forward pass; all length prefixes appear before their content.

In particular:

Field ordering MUST NOT vary.
No alternative encodings (e.g. different integer widths, string formats, or positions) are permitted.
EncodedRef MUST always use canonical ReferenceBytes from ENC/ASL1-CORE v1 (and therefore, when HASH/ASL1 is present, inherit its digest-length consistency checks).

For the canonical DAG scheme, DagSchemeDescriptor_DAG_1 encodes to a single, immutable DagSchemeDescriptorBytes_DAG_1. That byte sequence MUST NOT change once published.

4.5 Error handling (encoding layer)

Decoders for this profile MUST treat as encoding errors at the descriptor level:

Unsupported pel1_version
- pel1_version != 1.
Invalid presence flags
- has_trace_profile or has_opreg_ref not in { 0x00, 0x01 }.
Invalid EncodedRef
- ref_len < 2, or
- insufficient bytes to read ref_bytes, or
- ref_bytes cannot be decoded as ReferenceBytes under ENC/ASL1-CORE v1 (including digest-length mismatches for known hash_ids when HASH/ASL1 is implemented).
Invalid Utf8String for scheme_name
- scheme_name bytes are not valid UTF-8.
Truncation and over-long payloads
- Not enough bytes to read any declared field.
- In contexts expecting a single descriptor value, additional trailing bytes after decoding all fields.

Mapping from these encoding errors to external error codes (e.g. ERR_PEL_SCHEME_DESC_INVALID) is implementation-specific.

5. Definition of `SchemeRef_DAG_1`

5.1 General derivation from the descriptor Artifact

Let DagSchemeDescriptorArtifact be any Artifact of the form:

Artifact {
  type_tag = TYPE_TAG_PEL_SCHEME_DESC_1
  bytes    = DagSchemeDescriptorBytes
}

such that DagSchemeDescriptorBytes decodes to some DagSchemeDescriptor value via decode_dag_scheme_descriptor_v1.

Given:

encoding profile P = ASL_ENC_CORE_V1,
hash algorithm H with HashId = HID,

the scheme reference for this descriptor under (P, H) is:

ArtifactBytes = encode_artifact_core_v1(DagSchemeDescriptorArtifact)
digest        = H(ArtifactBytes)
SchemeRef     = Reference { hash_id = HID, digest = digest }

This is ASL/CORE-REF-DERIVE/1 instantiated with ASL_ENC_CORE_V1.

5.2 Canonical `SchemeRef_DAG_1` for Amduat 2.0

For the Amduat 2.0 baseline DAG scheme, we choose:

DagSchemeDescriptorArtifact = DagSchemeDescriptorArtifact_DAG_1,
P = ASL_ENC_CORE_V1 (EncodingProfileId = 0x0001),
H = HASH-ASL1-256 (the mandatory ASL1-256 algorithm),
HashId(H) = 0x0001.

Then:

ArtifactBytes_DAG_1 = encode_artifact_core_v1(DagSchemeDescriptorArtifact_DAG_1)
digest_DAG_1        = HASH-ASL1-256(ArtifactBytes_DAG_1)
SchemeRef_DAG_1     = Reference { hash_id = 0x0001, digest = digest_DAG_1 }

In the Amduat 2.0 baseline:

PEL/PROGRAM-DAG/1 binds its scheme symbol:
```
SchemeRef = SchemeRef_DAG_1
Exec_s    = Exec_DAG
```
to this Reference.
Engines that implement the Amduat 2.0 baseline DAG scheme MUST treat this specific Reference as “the” scheme identifier for PEL/PROGRAM-DAG/1.

5.3 Alternative deployments (non-baseline)

Other deployments MAY derive alternative scheme references from:

the same descriptor Artifact but a different (EncodingProfileId, HashId) pair, or
a different descriptor Artifact (e.g. one with additional optional references or different metadata).

Such configurations:

are not the Amduat 2.0 baseline, and
MUST NOT reuse the name SchemeRef_DAG_1 for any scheme reference other than the one defined in §5.2.

Profiles MAY define their own symbolic names (e.g. SchemeRef_DAG_1_PQ) for alternate (EncodingProfileId, HashId) combinations, but those are outside the scope of this document.

6. Layering & Usage

6.1 Engine behavior

A PEL/1-CORE engine that claims support for the DAG scheme in the Amduat 2.0 baseline:

MUST recognize SchemeRef_DAG_1 (as defined in §5.2) as the scheme identifier corresponding to PEL/PROGRAM-DAG/1.
MUST implement:
```
Exec_s = Exec_DAG
```
when invoked with scheme_ref = SchemeRef_DAG_1.
MUST treat Program Artifacts for this scheme as ASL/1 Artifacts whose type_tag equals the program_type_tag from the descriptor (i.e. TYPE_TAG_PEL_PROGRAM_DAG_1). The program_enc_profile field gives the encoding profile ID that engines use to select the appropriate Program encoding/decoding logic; in the Amduat 2.0 baseline this ID is PEL_ENC_PROGRAM_DAG_V1 as defined in ENC/PEL-PROGRAM-DAG/1.
MUST treat the descriptor Artifact as immutable metadata. Engines MAY bake in SchemeRef_DAG_1 and the associated TypeTag and profile IDs at build time; they are not required to fetch or decode the descriptor on the execution hot path.

Nothing in this document requires engines to use trace_profile_ref or opreg_ref at runtime. Those fields exist so that tooling and profiles can discover related descriptors in a stable, content-addressed way.

6.2 Configuration and discovery

Tooling and configuration systems MAY use the descriptor to:

discover:
- which TypeTag is used for DAG Programs,
- which encoding profile ID applies to those Programs,
- optional references to trace and operation-registry descriptors;

populate engine configuration tables, e.g.:

scheme_table[SchemeRef_DAG_1] = {
  program_type_tag    = TYPE_TAG_PEL_PROGRAM_DAG_1,
  program_enc_profile = PEL_ENC_PROGRAM_DAG_V1,
  trace_profile_ref   = None,
  opreg_ref           = None,
}

This document:

MUST NOT introduce any store-level behavior, TGK edge semantics, certification rules, fact semantics, or overlay semantics.
ONLY binds PEL-level scheme semantics (Exec_DAG) to ASL-level values (Artifact, TypeTag, Reference).

7. Conformance

An implementation is PEL/PROGRAM-DAG-DESC/1–conformant if it satisfies all of:

Descriptor encoding & decoding
- Implements encode_dag_scheme_descriptor_v1 / decode_dag_scheme_descriptor_v1 as in §4.2–§4.3.
- Treats pel1_version = 1 as the only supported version for this descriptor profile.
- Enforces presence flags and EncodedRef structure as defined in §2.4 and §4.5.
Recognition of the descriptor Artifact
- Recognizes TYPE_TAG_PEL_SCHEME_DESC_1 as the PEL scheme descriptor tag for this document.
- For type_tag = TYPE_TAG_PEL_SCHEME_DESC_1, is able to decode bytes as DagSchemeDescriptorBytes and obtain a DagSchemeDescriptor.
- Recognizes DagSchemeDescriptor_DAG_1 (per §3.3) as the canonical descriptor value for the DAG scheme in Amduat 2.0 (e.g. by comparing decoded fields).
Derivation of SchemeRef_DAG_1
- When configured with ASL_ENC_CORE_V1 and HASH-ASL1-256 (HashId = 0x0001), derives SchemeRef_DAG_1 exactly as in §5.2 from DagSchemeDescriptorArtifact_DAG_1.
- Does not derive SchemeRef_DAG_1 from any other Artifact or under any other (EncodingProfileId, HashId) pair.
Scheme binding
- For SchemeRef = SchemeRef_DAG_1, implements Exec_s as Exec_DAG per PEL/PROGRAM-DAG/1.
- Uses program_type_tag and program_enc_profile from the descriptor when interpreting Program Artifacts for this scheme (at build time or configuration time; not necessarily on every execution).
Layering discipline
- Does not introduce store, TGK, certificate, fact, or overlay semantics into the descriptor logic.
- Treats this document purely as a binding between:
  - the PEL scheme (PEL/PROGRAM-DAG/1),
  - its program representation (TYPE_TAG_PEL_PROGRAM_DAG_1 + PEL_ENC_PROGRAM_DAG_V1),
  - and an ASL/1 SchemeRef (SchemeRef_DAG_1).

Everything else — store wiring, TGK edges, receipts, facts, overlays, and domain semantics — is delegated to other specifications.

8. Version History

0.1.6 — 2025-11-16 — Marked ENC/PEL-PROGRAM-DAG/1 as a normative dependency and clarified that program_enc_profile is specifically PEL_ENC_PROGRAM_DAG_V1.
0.1.5 — 2025-11-16 — Clarified the role of program_enc_profile vs ASL_ENC_CORE_V1 and tightened wording around how Program Artifacts are interpreted.
0.1.4 — 2025-11-16 — Tightened decoding wording, clarified the uniqueness of the encoding/decoding pair, and polished streaming/injectivity language.
0.1.3 — 2025-11-16 — Clarified RFC 2119 usage, layering around program encoding, and tightened conformance wording.
0.1.2 — 2025-11-16 — Refined encoding error rules, clarified TYPE_TAG_PEL_SCHEME_DESC_1 reuse, and described engine usage more explicitly.
0.1.1 — 2025-11-16 — Added logical descriptor model, descriptor Artifact & encoding, canonical descriptor value, and explicit SchemeRef_DAG_1 derivation.
0.1.0 — 2025-11-16 — Initial skeleton with structure, roles, and high-level field model for the DAG scheme descriptor.

Document History

0.1.6 (2025-11-16): Registered as Tier-1 spec and aligned to the Amduat 2.0 substrate baseline.

27 KiB Raw Blame History Unescape Escape