cjm-transcript-graph-schema 0.0.5__tar.gz → 0.0.6__tar.gz

{cjm_transcript_graph_schema-0.0.5/cjm_transcript_graph_schema.egg-info → cjm_transcript_graph_schema-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cjm-transcript-graph-schema
-Version: 0.0.5
+Version: 0.0.6
 Summary: Audio-transcript layer schema for context graphs: Source, AudioSegment, Transcript, and Segment nodes with deterministic identity tuples and graph-node mapping, shared by the transcription, decomposition, and correction workflow cores.
 Author-email: "Christian J. Mills" <9126128+cj-mills@users.noreply.github.com>
 License: Apache-2.0
@@ -30,7 +30,7 @@ pip install cjm_transcript_graph_schema
 ## Project Structure
 
     nbs/
-    └── schema.ipynb # The audio-transcript layer schema (where-graph-begins locked layer schema): `Source -> AudioSegment(coarse, owns the model-input WAV) -> Transcript(per-transcriber variants)` emitted by transcription, extended with the fine `Segment` spine by decomposition. Deterministic identity tuples per the stage-5 ratified rule; `Document` from the pre-CR-18 era dissolves into `Source`.
+    └── schema.ipynb # The audio-transcript layer schema (where-graph-begins locked layer schema): `Source -> AudioSegment(coarse boundary) -> AudioRendition(model-input: raw | vocals | …) -> Transcript(per-transcriber variants)` emitted by transcription, extended with the fine `Segment` spine (per-rendition) by decomposition. Deterministic identity tuples per the stage-5 ratified rule; the `AudioRendition` node lets raw + preprocessed model-inputs of one boundary coexist in one graph. `Document` from the pre-CR-18 era dissolves into `Source`.
 
 Total: 1 notebook
 
@@ -55,10 +55,12 @@ Detailed documentation for each module in the project:
 
 > The audio-transcript layer schema (where-graph-begins locked layer
 > schema):
-> `Source -> AudioSegment(coarse, owns the model-input WAV) -> Transcript(per-transcriber variants)`
-> emitted by transcription, extended with the fine `Segment` spine by
-> decomposition. Deterministic identity tuples per the stage-5 ratified
-> rule; `Document` from the pre-CR-18 era dissolves into `Source`.
+> `Source -> AudioSegment(coarse boundary) -> AudioRendition(model-input: raw | vocals | …) -> Transcript(per-transcriber variants)`
+> emitted by transcription, extended with the fine `Segment` spine
+> (per-rendition) by decomposition. Deterministic identity tuples per
+> the stage-5 ratified rule; the `AudioRendition` node lets raw +
+> preprocessed model-inputs of one boundary coexist in one graph.
+> `Document` from the pre-CR-18 era dissolves into `Source`.
 
 #### Import
 
@@ -67,10 +69,12 @@ from cjm_transcript_graph_schema.schema import (
     TranscriptGraphLabels,
     source_node_id,
     audio_segment_node_id,
+    audio_rendition_node_id,
     transcript_node_id,
     segment_node_id,
     SourceNode,
     AudioSegmentNode,
+    AudioRenditionNode,
     TranscriptNode,
     TranscriptSliceRef,
     SegmentNode
@@ -95,36 +99,60 @@ def audio_segment_node_id(
     """
     AudioSegment identity = (source, boundary range).
     
-    Conversion-config-independent: the model-input WAV is payload/provenance,
-    not identity — the boundary computation is pure and deterministic, so
-    re-derivation reproduces the id.
+    Rendition-independent by design: an AudioSegment is a BOUNDARY of the source
+    (an audio fact), shared across every model-input rendition of it. The
+    boundary computation is pure and deterministic, so re-derivation reproduces
+    the id; the model-input WAV lives on the `AudioRendition` child, not here.
     """
 ```
 
 ``` python
-def transcript_node_id(
+def audio_rendition_node_id(
     audio_segment_id: str,  # Owning AudioSegment node id
-    transcriber: str,       # Transcriber capability name (e.g. "cjm-transcription-plugin-whisper")
-    config_hash: str,       # Transcriber config hash
+    chain: List[str],       # Ordered preprocessing-chain descriptors; [] = the raw convert-only rendition
+) -> str:  # Deterministic AudioRendition node id
+    """
+    AudioRendition identity = (audio segment, preprocessing chain).
+    
+    A rendition is one model-input audio OF an AudioSegment. The chain is the
+    ordered list of preprocessing steps that produced it (each an opaque
+    descriptor string, e.g. ``"source_separation:cjm-media-plugin-demucs@<cfg>"``);
+    an EMPTY chain is the raw convert-only rendition, whose id is therefore
+    stable and chain-free. The universal 16k-mono resample is implicit (not a
+    chain step) — so raw + vocals are distinct renditions under one shared
+    AudioSegment, and the layer's identity-mismatch check never collides them.
+    Re-derivable from the manifest chain alone (extenders recompute, never
+    search).
+    """
+```
+
+``` python
+def transcript_node_id(
+    rendition_id: str,  # Owning AudioRendition node id
+    transcriber: str,   # Transcriber capability name (e.g. "cjm-transcription-plugin-whisper")
+    config_hash: str,   # Transcriber config hash
 ) -> str:  # Deterministic Transcript node id
     """
-    Transcript identity = (audio segment, transcriber, config) — MIRRORS the
+    Transcript identity = (audio rendition, transcriber, config) — MIRRORS the
     capability cache key UNIQUE(audio_path, config_hash), so the graph node is
-    the durable face of the cached row (the structural E13 fix).
+    the durable face of the cached row (the structural E13 fix). Keyed on the
+    RENDITION, so a raw vs vocals transcript of the same boundary are distinct.
     """
 ```
 
 ``` python
 def segment_node_id(
-    audio_segment_id: str,  # Owning AudioSegment node id
-    vad_config_hash: str,   # VAD capability config hash (skeleton identity input)
-    chunk_start: float,     # VAD chunk start (chunk-local seconds within the AudioSegment)
-    chunk_end: float,       # VAD chunk end (chunk-local seconds)
+    rendition_id: str,     # Owning AudioRendition node id
+    vad_config_hash: str,  # VAD capability config hash (skeleton identity input)
+    chunk_start: float,    # VAD chunk start (chunk-local seconds within the rendition WAV)
+    chunk_end: float,      # VAD chunk end (chunk-local seconds)
 ) -> str:  # Deterministic Segment node id
     """
-    Fine Segment identity = audio-side only (audio segment, VAD config, chunk
+    Fine Segment identity = audio-side only (audio rendition, VAD config, chunk
     range) — so the skeleton's ids are SHARED across transcribers by
-    construction (C4 "store agreement once" falls out of identity design).
+    construction (C4 "store agreement once" falls out of identity design). Keyed
+    on the RENDITION: each rendition has its own fine spine (vocals isolation can
+    yield different VAD chunk boundaries than raw).
     """
 ```
 
@@ -166,23 +194,23 @@ class SourceNode:
 @dataclass
 class AudioSegmentNode:
     """
-    Coarse ~5-min spine member. Owns the model-input WAV (E14: the audio of
-    record) as payload/provenance — the WAV is NOT its own node.
+    Coarse ~5-min spine member: a BOUNDARY range of the Source (an audio fact),
+    shared across every model-input rendition of it.
     
-    Provenance note (deliberate): the SourceRef anchors the owned model-input
-    WAV artifact (hash_file-verifiable). A hash over the sliced ORIGINAL source
-    bytes is not materializable without extracting per-range artifacts (decoded
-    ranges are not byte ranges); the structural chain to the Source rides the
-    PART_OF edge + the start/end properties.
+    Hashless by design: a boundary is not a materialized artifact — a hash over
+    the sliced ORIGINAL source bytes is not materializable without extracting
+    per-range artifacts (decoded ranges are not byte ranges). The materialized
+    model-input WAV lives on the `AudioRendition` child (which carries its
+    content hash); the structural chain to the Source rides the PART_OF edge +
+    the start/end properties. `segment_path` (the source-codec cut) stays here as
+    a rendition-independent archival pointer.
     """
     
     source: str  # Owning Source node id
     index: int  # Position in the coarse spine (0-based)
     start: float  # Boundary start (source-coordinate seconds)
     end: float  # Boundary end (source-coordinate seconds)
-    model_input_path: str  # The 16kHz mono WAV consumed by transcription/VAD/FA
-    model_input_hash: str  # Content hash over that WAV
-    segment_path: Optional[str]  # Source-codec cut file (archival pointer)
+    segment_path: Optional[str]  # Source-codec cut file (rendition-independent archival pointer)
     
     def id(self) -> str:  # Deterministic node id
             """Deterministic node id."""
@@ -192,30 +220,69 @@ class AudioSegmentNode:
         "Deterministic node id."
     
     def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
-            """Build the AudioSegment node wire dict."""
+            """Build the AudioSegment node wire dict (hashless boundary; sources empty)."""
             props: Dict[str, Any] = {
-        "Build the AudioSegment node wire dict."
+        "Build the AudioSegment node wire dict (hashless boundary; sources empty)."
+```
+
+``` python
+@dataclass
+class AudioRenditionNode:
+    """
+    A model-input rendition OF an AudioSegment — the materialized 16k-mono WAV
+    consumed by transcription/VAD/FA. OWNS the model-input (E14: the audio of
+    record); the AudioSegment above it is a hashless boundary.
+    
+    Identity = (audio segment, preprocessing chain). The raw convert-only path is
+    an empty chain (its id is stable + chain-free); vocals isolation / future
+    speech-enhancement are non-empty chains. Raw + vocals are therefore distinct
+    renditions that COEXIST under one AudioSegment — the divergent model-input
+    hash that used to collide the AudioSegment now lives on distinct rendition
+    nodes. Connects UP to its AudioSegment by DERIVED_FROM (it is derived from the
+    segment's audio); the production act is recorded separately by a CR-18
+    `Derivation` event.
+    """
+    
+    audio_segment: str  # Owning AudioSegment node id
+    model_input_path: str  # The 16kHz mono WAV consumed by transcription/VAD/FA
+    model_input_hash: str  # Content hash over that WAV (the rendition's identity-of-record artifact)
+    chain: List[str] = field(...)  # Ordered preprocessing-chain descriptors; [] = raw convert-only
+    
+    def id(self) -> str:  # Deterministic node id
+            """Deterministic node id."""
+            return audio_rendition_node_id(self.audio_segment, self.chain)
+    
+        def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
+        "Deterministic node id."
+    
+    def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
+            """Build the AudioRendition node wire dict (owns the model-input SourceRef)."""
+            props: Dict[str, Any] = {
+        "Build the AudioRendition node wire dict (owns the model-input SourceRef)."
+    
+    def derived_edge(self) -> Dict[str, Any]:  # Edge wire dict
+        "DERIVED_FROM edge: this rendition derives from its AudioSegment's audio."
 ```
 
 ``` python
 @dataclass
 class TranscriptNode:
     """
-    One transcriber's text for one AudioSegment (per-transcriber variants at
+    One transcriber's text for one AudioRendition (per-transcriber variants at
     the coarse layer — cross-transcriber divergence lives here, C4/C14).
     """
     
-    audio_segment: str  # Owning AudioSegment node id
+    rendition: str  # Owning AudioRendition node id
     transcriber: str  # Transcriber capability name
     config_hash: str  # Transcriber config hash
     text: str  # The transcript text (stored ONCE here; fine Segments slice into it)
-    audio_hash: str  # Content hash of the consumed model-input WAV
+    audio_hash: str  # Content hash of the consumed model-input WAV (the rendition's)
     metadata: Dict[str, Any] = field(...)  # Transcriber-reported metadata
     asserted_at: Optional[float]  # Derivation timestamp; None = now
     
     def id(self) -> str:  # Deterministic node id
             """Deterministic node id."""
-            return transcript_node_id(self.audio_segment, self.transcriber, self.config_hash)
+            return transcript_node_id(self.rendition, self.transcriber, self.config_hash)
     
         def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
         "Deterministic node id."
@@ -226,7 +293,7 @@ class TranscriptNode:
         "Build the Transcript node wire dict (capability attribution included)."
     
     def derived_edge(self) -> Dict[str, Any]:  # Edge wire dict
-        "DERIVED_FROM edge: this Transcript derives from its AudioSegment."
+        "DERIVED_FROM edge: this Transcript derives from its AudioRendition."
 ```
 
 ``` python
@@ -252,7 +319,8 @@ class TranscriptSliceRef:
 class SegmentNode:
     """
     Fine spine member: one VAD chunk — IMMUTABLE audio range + CORRECTABLE
-    text (the immutable-audio/mutable-text spine seam).
+    text (the immutable-audio/mutable-text spine seam). PART_OF its AudioRendition
+    (each rendition has its own fine spine).
     
     Layer-0 `text` is the ACCURACY transcriber's alignment; the designation is
     per-segment provenance, not global config (`text_from` names the
@@ -260,26 +328,26 @@ class SegmentNode:
     `text_slices`, the authoritative one included).
     """
     
-    audio_segment: str  # Owning AudioSegment node id
+    rendition: str  # Owning AudioRendition node id
     vad_config_hash: str  # VAD config hash (skeleton identity input)
-    chunk_start: float  # VAD chunk start (chunk-local seconds within the AudioSegment WAV)
+    chunk_start: float  # VAD chunk start (chunk-local seconds within the rendition WAV)
     chunk_end: float  # VAD chunk end (chunk-local seconds)
     index: int  # Source-wide fine-spine index (0-based)
     start_time: float  # Source-coordinate start (navigation)
     end_time: float  # Source-coordinate end
     text: str = ''  # Layer-0 text (accuracy alignment; "" = no aligned words, D14 class)
-    audio_hash: str = ''  # Content hash of the owning AudioSegment's model-input WAV
+    audio_hash: str = ''  # Content hash of the owning rendition's model-input WAV
     source: Optional[str]  # Source node id (convenience for direct filters)
     text_from: Optional[str]  # Authoritative Transcript node id (None when text is empty)
     text_slices: List[TranscriptSliceRef] = field(...)  # All per-transcriber slice refs
     
     def id(self) -> str:  # Deterministic node id
-            """Deterministic node id (audio-side identity; shared across transcribers)."""
-            return segment_node_id(self.audio_segment, self.vad_config_hash,
+            """Deterministic node id (audio-side identity; shared across transcribers, per-rendition)."""
+            return segment_node_id(self.rendition, self.vad_config_hash,
                                    self.chunk_start, self.chunk_end)
     
         def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
-        "Deterministic node id (audio-side identity; shared across transcribers)."
+        "Deterministic node id (audio-side identity; shared across transcribers, per-rendition)."
     
     def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
             """Build the Segment node wire dict (audio ref + per-transcriber text slice refs)."""

{cjm_transcript_graph_schema-0.0.5 → cjm_transcript_graph_schema-0.0.6}/README.md

@@ -12,7 +12,7 @@ pip install cjm_transcript_graph_schema
 ## Project Structure
 
     nbs/
-    └── schema.ipynb # The audio-transcript layer schema (where-graph-begins locked layer schema): `Source -> AudioSegment(coarse, owns the model-input WAV) -> Transcript(per-transcriber variants)` emitted by transcription, extended with the fine `Segment` spine by decomposition. Deterministic identity tuples per the stage-5 ratified rule; `Document` from the pre-CR-18 era dissolves into `Source`.
+    └── schema.ipynb # The audio-transcript layer schema (where-graph-begins locked layer schema): `Source -> AudioSegment(coarse boundary) -> AudioRendition(model-input: raw | vocals | …) -> Transcript(per-transcriber variants)` emitted by transcription, extended with the fine `Segment` spine (per-rendition) by decomposition. Deterministic identity tuples per the stage-5 ratified rule; the `AudioRendition` node lets raw + preprocessed model-inputs of one boundary coexist in one graph. `Document` from the pre-CR-18 era dissolves into `Source`.
 
 Total: 1 notebook
 
@@ -37,10 +37,12 @@ Detailed documentation for each module in the project:
 
 > The audio-transcript layer schema (where-graph-begins locked layer
 > schema):
-> `Source -> AudioSegment(coarse, owns the model-input WAV) -> Transcript(per-transcriber variants)`
-> emitted by transcription, extended with the fine `Segment` spine by
-> decomposition. Deterministic identity tuples per the stage-5 ratified
-> rule; `Document` from the pre-CR-18 era dissolves into `Source`.
+> `Source -> AudioSegment(coarse boundary) -> AudioRendition(model-input: raw | vocals | …) -> Transcript(per-transcriber variants)`
+> emitted by transcription, extended with the fine `Segment` spine
+> (per-rendition) by decomposition. Deterministic identity tuples per
+> the stage-5 ratified rule; the `AudioRendition` node lets raw +
+> preprocessed model-inputs of one boundary coexist in one graph.
+> `Document` from the pre-CR-18 era dissolves into `Source`.
 
 #### Import
 
@@ -49,10 +51,12 @@ from cjm_transcript_graph_schema.schema import (
     TranscriptGraphLabels,
     source_node_id,
     audio_segment_node_id,
+    audio_rendition_node_id,
     transcript_node_id,
     segment_node_id,
     SourceNode,
     AudioSegmentNode,
+    AudioRenditionNode,
     TranscriptNode,
     TranscriptSliceRef,
     SegmentNode
@@ -77,36 +81,60 @@ def audio_segment_node_id(
     """
     AudioSegment identity = (source, boundary range).
     
-    Conversion-config-independent: the model-input WAV is payload/provenance,
-    not identity — the boundary computation is pure and deterministic, so
-    re-derivation reproduces the id.
+    Rendition-independent by design: an AudioSegment is a BOUNDARY of the source
+    (an audio fact), shared across every model-input rendition of it. The
+    boundary computation is pure and deterministic, so re-derivation reproduces
+    the id; the model-input WAV lives on the `AudioRendition` child, not here.
     """
 ```
 
 ``` python
-def transcript_node_id(
+def audio_rendition_node_id(
     audio_segment_id: str,  # Owning AudioSegment node id
-    transcriber: str,       # Transcriber capability name (e.g. "cjm-transcription-plugin-whisper")
-    config_hash: str,       # Transcriber config hash
+    chain: List[str],       # Ordered preprocessing-chain descriptors; [] = the raw convert-only rendition
+) -> str:  # Deterministic AudioRendition node id
+    """
+    AudioRendition identity = (audio segment, preprocessing chain).
+    
+    A rendition is one model-input audio OF an AudioSegment. The chain is the
+    ordered list of preprocessing steps that produced it (each an opaque
+    descriptor string, e.g. ``"source_separation:cjm-media-plugin-demucs@<cfg>"``);
+    an EMPTY chain is the raw convert-only rendition, whose id is therefore
+    stable and chain-free. The universal 16k-mono resample is implicit (not a
+    chain step) — so raw + vocals are distinct renditions under one shared
+    AudioSegment, and the layer's identity-mismatch check never collides them.
+    Re-derivable from the manifest chain alone (extenders recompute, never
+    search).
+    """
+```
+
+``` python
+def transcript_node_id(
+    rendition_id: str,  # Owning AudioRendition node id
+    transcriber: str,   # Transcriber capability name (e.g. "cjm-transcription-plugin-whisper")
+    config_hash: str,   # Transcriber config hash
 ) -> str:  # Deterministic Transcript node id
     """
-    Transcript identity = (audio segment, transcriber, config) — MIRRORS the
+    Transcript identity = (audio rendition, transcriber, config) — MIRRORS the
     capability cache key UNIQUE(audio_path, config_hash), so the graph node is
-    the durable face of the cached row (the structural E13 fix).
+    the durable face of the cached row (the structural E13 fix). Keyed on the
+    RENDITION, so a raw vs vocals transcript of the same boundary are distinct.
     """
 ```
 
 ``` python
 def segment_node_id(
-    audio_segment_id: str,  # Owning AudioSegment node id
-    vad_config_hash: str,   # VAD capability config hash (skeleton identity input)
-    chunk_start: float,     # VAD chunk start (chunk-local seconds within the AudioSegment)
-    chunk_end: float,       # VAD chunk end (chunk-local seconds)
+    rendition_id: str,     # Owning AudioRendition node id
+    vad_config_hash: str,  # VAD capability config hash (skeleton identity input)
+    chunk_start: float,    # VAD chunk start (chunk-local seconds within the rendition WAV)
+    chunk_end: float,      # VAD chunk end (chunk-local seconds)
 ) -> str:  # Deterministic Segment node id
     """
-    Fine Segment identity = audio-side only (audio segment, VAD config, chunk
+    Fine Segment identity = audio-side only (audio rendition, VAD config, chunk
     range) — so the skeleton's ids are SHARED across transcribers by
-    construction (C4 "store agreement once" falls out of identity design).
+    construction (C4 "store agreement once" falls out of identity design). Keyed
+    on the RENDITION: each rendition has its own fine spine (vocals isolation can
+    yield different VAD chunk boundaries than raw).
     """
 ```
 
@@ -148,23 +176,23 @@ class SourceNode:
 @dataclass
 class AudioSegmentNode:
     """
-    Coarse ~5-min spine member. Owns the model-input WAV (E14: the audio of
-    record) as payload/provenance — the WAV is NOT its own node.
+    Coarse ~5-min spine member: a BOUNDARY range of the Source (an audio fact),
+    shared across every model-input rendition of it.
     
-    Provenance note (deliberate): the SourceRef anchors the owned model-input
-    WAV artifact (hash_file-verifiable). A hash over the sliced ORIGINAL source
-    bytes is not materializable without extracting per-range artifacts (decoded
-    ranges are not byte ranges); the structural chain to the Source rides the
-    PART_OF edge + the start/end properties.
+    Hashless by design: a boundary is not a materialized artifact — a hash over
+    the sliced ORIGINAL source bytes is not materializable without extracting
+    per-range artifacts (decoded ranges are not byte ranges). The materialized
+    model-input WAV lives on the `AudioRendition` child (which carries its
+    content hash); the structural chain to the Source rides the PART_OF edge +
+    the start/end properties. `segment_path` (the source-codec cut) stays here as
+    a rendition-independent archival pointer.
     """
     
     source: str  # Owning Source node id
     index: int  # Position in the coarse spine (0-based)
     start: float  # Boundary start (source-coordinate seconds)
     end: float  # Boundary end (source-coordinate seconds)
-    model_input_path: str  # The 16kHz mono WAV consumed by transcription/VAD/FA
-    model_input_hash: str  # Content hash over that WAV
-    segment_path: Optional[str]  # Source-codec cut file (archival pointer)
+    segment_path: Optional[str]  # Source-codec cut file (rendition-independent archival pointer)
     
     def id(self) -> str:  # Deterministic node id
             """Deterministic node id."""
@@ -174,30 +202,69 @@ class AudioSegmentNode:
         "Deterministic node id."
     
     def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
-            """Build the AudioSegment node wire dict."""
+            """Build the AudioSegment node wire dict (hashless boundary; sources empty)."""
             props: Dict[str, Any] = {
-        "Build the AudioSegment node wire dict."
+        "Build the AudioSegment node wire dict (hashless boundary; sources empty)."
+```
+
+``` python
+@dataclass
+class AudioRenditionNode:
+    """
+    A model-input rendition OF an AudioSegment — the materialized 16k-mono WAV
+    consumed by transcription/VAD/FA. OWNS the model-input (E14: the audio of
+    record); the AudioSegment above it is a hashless boundary.
+    
+    Identity = (audio segment, preprocessing chain). The raw convert-only path is
+    an empty chain (its id is stable + chain-free); vocals isolation / future
+    speech-enhancement are non-empty chains. Raw + vocals are therefore distinct
+    renditions that COEXIST under one AudioSegment — the divergent model-input
+    hash that used to collide the AudioSegment now lives on distinct rendition
+    nodes. Connects UP to its AudioSegment by DERIVED_FROM (it is derived from the
+    segment's audio); the production act is recorded separately by a CR-18
+    `Derivation` event.
+    """
+    
+    audio_segment: str  # Owning AudioSegment node id
+    model_input_path: str  # The 16kHz mono WAV consumed by transcription/VAD/FA
+    model_input_hash: str  # Content hash over that WAV (the rendition's identity-of-record artifact)
+    chain: List[str] = field(...)  # Ordered preprocessing-chain descriptors; [] = raw convert-only
+    
+    def id(self) -> str:  # Deterministic node id
+            """Deterministic node id."""
+            return audio_rendition_node_id(self.audio_segment, self.chain)
+    
+        def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
+        "Deterministic node id."
+    
+    def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
+            """Build the AudioRendition node wire dict (owns the model-input SourceRef)."""
+            props: Dict[str, Any] = {
+        "Build the AudioRendition node wire dict (owns the model-input SourceRef)."
+    
+    def derived_edge(self) -> Dict[str, Any]:  # Edge wire dict
+        "DERIVED_FROM edge: this rendition derives from its AudioSegment's audio."
 ```
 
 ``` python
 @dataclass
 class TranscriptNode:
     """
-    One transcriber's text for one AudioSegment (per-transcriber variants at
+    One transcriber's text for one AudioRendition (per-transcriber variants at
     the coarse layer — cross-transcriber divergence lives here, C4/C14).
     """
     
-    audio_segment: str  # Owning AudioSegment node id
+    rendition: str  # Owning AudioRendition node id
     transcriber: str  # Transcriber capability name
     config_hash: str  # Transcriber config hash
     text: str  # The transcript text (stored ONCE here; fine Segments slice into it)
-    audio_hash: str  # Content hash of the consumed model-input WAV
+    audio_hash: str  # Content hash of the consumed model-input WAV (the rendition's)
     metadata: Dict[str, Any] = field(...)  # Transcriber-reported metadata
     asserted_at: Optional[float]  # Derivation timestamp; None = now
     
     def id(self) -> str:  # Deterministic node id
             """Deterministic node id."""
-            return transcript_node_id(self.audio_segment, self.transcriber, self.config_hash)
+            return transcript_node_id(self.rendition, self.transcriber, self.config_hash)
     
         def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
         "Deterministic node id."
@@ -208,7 +275,7 @@ class TranscriptNode:
         "Build the Transcript node wire dict (capability attribution included)."
     
     def derived_edge(self) -> Dict[str, Any]:  # Edge wire dict
-        "DERIVED_FROM edge: this Transcript derives from its AudioSegment."
+        "DERIVED_FROM edge: this Transcript derives from its AudioRendition."
 ```
 
 ``` python
@@ -234,7 +301,8 @@ class TranscriptSliceRef:
 class SegmentNode:
     """
     Fine spine member: one VAD chunk — IMMUTABLE audio range + CORRECTABLE
-    text (the immutable-audio/mutable-text spine seam).
+    text (the immutable-audio/mutable-text spine seam). PART_OF its AudioRendition
+    (each rendition has its own fine spine).
     
     Layer-0 `text` is the ACCURACY transcriber's alignment; the designation is
     per-segment provenance, not global config (`text_from` names the
@@ -242,26 +310,26 @@ class SegmentNode:
     `text_slices`, the authoritative one included).
     """
     
-    audio_segment: str  # Owning AudioSegment node id
+    rendition: str  # Owning AudioRendition node id
     vad_config_hash: str  # VAD config hash (skeleton identity input)
-    chunk_start: float  # VAD chunk start (chunk-local seconds within the AudioSegment WAV)
+    chunk_start: float  # VAD chunk start (chunk-local seconds within the rendition WAV)
     chunk_end: float  # VAD chunk end (chunk-local seconds)
     index: int  # Source-wide fine-spine index (0-based)
     start_time: float  # Source-coordinate start (navigation)
     end_time: float  # Source-coordinate end
     text: str = ''  # Layer-0 text (accuracy alignment; "" = no aligned words, D14 class)
-    audio_hash: str = ''  # Content hash of the owning AudioSegment's model-input WAV
+    audio_hash: str = ''  # Content hash of the owning rendition's model-input WAV
     source: Optional[str]  # Source node id (convenience for direct filters)
     text_from: Optional[str]  # Authoritative Transcript node id (None when text is empty)
     text_slices: List[TranscriptSliceRef] = field(...)  # All per-transcriber slice refs
     
     def id(self) -> str:  # Deterministic node id
-            """Deterministic node id (audio-side identity; shared across transcribers)."""
-            return segment_node_id(self.audio_segment, self.vad_config_hash,
+            """Deterministic node id (audio-side identity; shared across transcribers, per-rendition)."""
+            return segment_node_id(self.rendition, self.vad_config_hash,
                                    self.chunk_start, self.chunk_end)
     
         def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
-        "Deterministic node id (audio-side identity; shared across transcribers)."
+        "Deterministic node id (audio-side identity; shared across transcribers, per-rendition)."
     
     def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
             """Build the Segment node wire dict (audio ref + per-transcriber text slice refs)."""

cjm_transcript_graph_schema-0.0.6/cjm_transcript_graph_schema/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.6"

{cjm_transcript_graph_schema-0.0.5 → cjm_transcript_graph_schema-0.0.6}/cjm_transcript_graph_schema/_modidx.py

@@ -5,7 +5,15 @@ d = { 'settings': { 'branch': 'main',
                 'doc_host': 'https://cj-mills.github.io',
                 'git_url': 'https://github.com/cj-mills/cjm-transcript-graph-schema',
                 'lib_path': 'cjm_transcript_graph_schema'},
-  'syms': { 'cjm_transcript_graph_schema.schema': { 'cjm_transcript_graph_schema.schema.AudioSegmentNode': ( 'schema.html#audiosegmentnode',
+  'syms': { 'cjm_transcript_graph_schema.schema': { 'cjm_transcript_graph_schema.schema.AudioRenditionNode': ( 'schema.html#audiorenditionnode',
+                                                                                                               'cjm_transcript_graph_schema/schema.py'),
+                                                    'cjm_transcript_graph_schema.schema.AudioRenditionNode.derived_edge': ( 'schema.html#audiorenditionnode.derived_edge',
+                                                                                                                            'cjm_transcript_graph_schema/schema.py'),
+                                                    'cjm_transcript_graph_schema.schema.AudioRenditionNode.id': ( 'schema.html#audiorenditionnode.id',
+                                                                                                                  'cjm_transcript_graph_schema/schema.py'),
+                                                    'cjm_transcript_graph_schema.schema.AudioRenditionNode.to_graph_node': ( 'schema.html#audiorenditionnode.to_graph_node',
+                                                                                                                             'cjm_transcript_graph_schema/schema.py'),
+                                                    'cjm_transcript_graph_schema.schema.AudioSegmentNode': ( 'schema.html#audiosegmentnode',
                                                                                                              'cjm_transcript_graph_schema/schema.py'),
                                                     'cjm_transcript_graph_schema.schema.AudioSegmentNode.id': ( 'schema.html#audiosegmentnode.id',
                                                                                                                 'cjm_transcript_graph_schema/schema.py'),
@@ -39,6 +47,8 @@ d = { 'settings': { 'branch': 'main',
                                                                                                                'cjm_transcript_graph_schema/schema.py'),
                                                     'cjm_transcript_graph_schema.schema.TranscriptSliceRef.to_source_ref': ( 'schema.html#transcriptsliceref.to_source_ref',
                                                                                                                              'cjm_transcript_graph_schema/schema.py'),
+                                                    'cjm_transcript_graph_schema.schema.audio_rendition_node_id': ( 'schema.html#audio_rendition_node_id',
+                                                                                                                    'cjm_transcript_graph_schema/schema.py'),
                                                     'cjm_transcript_graph_schema.schema.audio_segment_node_id': ( 'schema.html#audio_segment_node_id',
                                                                                                                   'cjm_transcript_graph_schema/schema.py'),
                                                     'cjm_transcript_graph_schema.schema.segment_node_id': ( 'schema.html#segment_node_id',

{cjm_transcript_graph_schema-0.0.5 → cjm_transcript_graph_schema-0.0.6}/cjm_transcript_graph_schema/schema.py

@@ -1,12 +1,13 @@
-"""The audio-transcript layer schema (where-graph-begins locked layer schema): `Source -> AudioSegment(coarse, owns the model-input WAV) -> Transcript(per-transcriber variants)` emitted by transcription, extended with the fine `Segment` spine by decomposition. Deterministic identity tuples per the stage-5 ratified rule; `Document` from the pre-CR-18 era dissolves into `Source`.
+"""The audio-transcript layer schema (where-graph-begins locked layer schema): `Source -> AudioSegment(coarse boundary) -> AudioRendition(model-input: raw | vocals | …) -> Transcript(per-transcriber variants)` emitted by transcription, extended with the fine `Segment` spine (per-rendition) by decomposition. Deterministic identity tuples per the stage-5 ratified rule; the `AudioRendition` node lets raw + preprocessed model-inputs of one boundary coexist in one graph. `Document` from the pre-CR-18 era dissolves into `Source`.
 
 Docs: https://cj-mills.github.io/cjm-transcript-graph-schemaschema.html.md"""
 
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/schema.ipynb.
 
 # %% auto #0
-__all__ = ['TranscriptGraphLabels', 'source_node_id', 'audio_segment_node_id', 'transcript_node_id', 'segment_node_id',
-           'SourceNode', 'AudioSegmentNode', 'TranscriptNode', 'TranscriptSliceRef', 'SegmentNode']
+__all__ = ['TranscriptGraphLabels', 'source_node_id', 'audio_segment_node_id', 'audio_rendition_node_id', 'transcript_node_id',
+           'segment_node_id', 'SourceNode', 'AudioSegmentNode', 'AudioRenditionNode', 'TranscriptNode',
+           'TranscriptSliceRef', 'SegmentNode']
 
 # %% ../nbs/schema.ipynb #76d0dd1c
 from pathlib import Path
@@ -22,15 +23,16 @@ from cjm_context_graph_primitives.provenance import SourceRef
 # %% ../nbs/schema.ipynb #ff94773a
 class TranscriptGraphLabels:
     """Node labels of the audio-transcript layer schema."""
-    SOURCE = "Source"               # Provenance root: one ingested media file
-    AUDIO_SEGMENT = "AudioSegment"  # Coarse ~5-min spine member; owns the model-input WAV
-    TRANSCRIPT = "Transcript"       # Per-transcriber text variant of one AudioSegment
-    SEGMENT = "Segment"             # Fine spine member: one VAD chunk (immutable audio + correctable text)
+    SOURCE = "Source"                  # Provenance root: one ingested media file
+    AUDIO_SEGMENT = "AudioSegment"     # Coarse ~5-min spine member: a boundary range of the Source (an audio FACT; rendition-independent)
+    AUDIO_RENDITION = "AudioRendition" # A model-input rendition OF an AudioSegment (raw convert | vocals | future enhancement); OWNS the model-input WAV
+    TRANSCRIPT = "Transcript"          # Per-transcriber text variant of one AudioRendition
+    SEGMENT = "Segment"                # Fine spine member: one VAD chunk (immutable audio + correctable text), per-rendition
 
     @classmethod
     def all(cls) -> list:  # All schema labels
         """All schema labels."""
-        return [cls.SOURCE, cls.AUDIO_SEGMENT, cls.TRANSCRIPT, cls.SEGMENT]
+        return [cls.SOURCE, cls.AUDIO_SEGMENT, cls.AUDIO_RENDITION, cls.TRANSCRIPT, cls.SEGMENT]
 
 # %% ../nbs/schema.ipynb #a5ea12db
 def source_node_id(
@@ -47,33 +49,55 @@ def audio_segment_node_id(
 ) -> str:  # Deterministic AudioSegment node id
     """AudioSegment identity = (source, boundary range).
 
-    Conversion-config-independent: the model-input WAV is payload/provenance,
-    not identity — the boundary computation is pure and deterministic, so
-    re-derivation reproduces the id."""
+    Rendition-independent by design: an AudioSegment is a BOUNDARY of the source
+    (an audio fact), shared across every model-input rendition of it. The
+    boundary computation is pure and deterministic, so re-derivation reproduces
+    the id; the model-input WAV lives on the `AudioRendition` child, not here."""
     return derive_node_id("audio-segment", source_id, start, end)
 
+# %% ../nbs/schema.ipynb #8e147ac9
+def audio_rendition_node_id(
+    audio_segment_id: str,  # Owning AudioSegment node id
+    chain: List[str],       # Ordered preprocessing-chain descriptors; [] = the raw convert-only rendition
+) -> str:  # Deterministic AudioRendition node id
+    """AudioRendition identity = (audio segment, preprocessing chain).
+
+    A rendition is one model-input audio OF an AudioSegment. The chain is the
+    ordered list of preprocessing steps that produced it (each an opaque
+    descriptor string, e.g. ``"source_separation:cjm-media-plugin-demucs@<cfg>"``);
+    an EMPTY chain is the raw convert-only rendition, whose id is therefore
+    stable and chain-free. The universal 16k-mono resample is implicit (not a
+    chain step) — so raw + vocals are distinct renditions under one shared
+    AudioSegment, and the layer's identity-mismatch check never collides them.
+    Re-derivable from the manifest chain alone (extenders recompute, never
+    search)."""
+    return derive_node_id("audio-rendition", audio_segment_id, *chain)
+
 # %% ../nbs/schema.ipynb #6fe30fc8
 def transcript_node_id(
-    audio_segment_id: str,  # Owning AudioSegment node id
-    transcriber: str,       # Transcriber capability name (e.g. "cjm-transcription-plugin-whisper")
-    config_hash: str,       # Transcriber config hash
+    rendition_id: str,  # Owning AudioRendition node id
+    transcriber: str,   # Transcriber capability name (e.g. "cjm-transcription-plugin-whisper")
+    config_hash: str,   # Transcriber config hash
 ) -> str:  # Deterministic Transcript node id
-    """Transcript identity = (audio segment, transcriber, config) — MIRRORS the
+    """Transcript identity = (audio rendition, transcriber, config) — MIRRORS the
     capability cache key UNIQUE(audio_path, config_hash), so the graph node is
-    the durable face of the cached row (the structural E13 fix)."""
-    return derive_node_id("transcript", audio_segment_id, transcriber, config_hash)
+    the durable face of the cached row (the structural E13 fix). Keyed on the
+    RENDITION, so a raw vs vocals transcript of the same boundary are distinct."""
+    return derive_node_id("transcript", rendition_id, transcriber, config_hash)
 
 # %% ../nbs/schema.ipynb #f0e4f510
 def segment_node_id(
-    audio_segment_id: str,  # Owning AudioSegment node id
-    vad_config_hash: str,   # VAD capability config hash (skeleton identity input)
-    chunk_start: float,     # VAD chunk start (chunk-local seconds within the AudioSegment)
-    chunk_end: float,       # VAD chunk end (chunk-local seconds)
+    rendition_id: str,     # Owning AudioRendition node id
+    vad_config_hash: str,  # VAD capability config hash (skeleton identity input)
+    chunk_start: float,    # VAD chunk start (chunk-local seconds within the rendition WAV)
+    chunk_end: float,      # VAD chunk end (chunk-local seconds)
 ) -> str:  # Deterministic Segment node id
-    """Fine Segment identity = audio-side only (audio segment, VAD config, chunk
+    """Fine Segment identity = audio-side only (audio rendition, VAD config, chunk
     range) — so the skeleton's ids are SHARED across transcribers by
-    construction (C4 "store agreement once" falls out of identity design)."""
-    return derive_node_id("segment", audio_segment_id, vad_config_hash, chunk_start, chunk_end)
+    construction (C4 "store agreement once" falls out of identity design). Keyed
+    on the RENDITION: each rendition has its own fine spine (vocals isolation can
+    yield different VAD chunk boundaries than raw)."""
+    return derive_node_id("segment", rendition_id, vad_config_hash, chunk_start, chunk_end)
 
 # %% ../nbs/schema.ipynb #d768584a
 @dataclass
@@ -107,21 +131,21 @@ class SourceNode:
 # %% ../nbs/schema.ipynb #3d76c961
 @dataclass
 class AudioSegmentNode:
-    """Coarse ~5-min spine member. Owns the model-input WAV (E14: the audio of
-    record) as payload/provenance — the WAV is NOT its own node.
-
-    Provenance note (deliberate): the SourceRef anchors the owned model-input
-    WAV artifact (hash_file-verifiable). A hash over the sliced ORIGINAL source
-    bytes is not materializable without extracting per-range artifacts (decoded
-    ranges are not byte ranges); the structural chain to the Source rides the
-    PART_OF edge + the start/end properties."""
+    """Coarse ~5-min spine member: a BOUNDARY range of the Source (an audio fact),
+    shared across every model-input rendition of it.
+
+    Hashless by design: a boundary is not a materialized artifact — a hash over
+    the sliced ORIGINAL source bytes is not materializable without extracting
+    per-range artifacts (decoded ranges are not byte ranges). The materialized
+    model-input WAV lives on the `AudioRendition` child (which carries its
+    content hash); the structural chain to the Source rides the PART_OF edge +
+    the start/end properties. `segment_path` (the source-codec cut) stays here as
+    a rendition-independent archival pointer."""
     source: str                       # Owning Source node id
     index: int                        # Position in the coarse spine (0-based)
     start: float                      # Boundary start (source-coordinate seconds)
     end: float                        # Boundary end (source-coordinate seconds)
-    model_input_path: str             # The 16kHz mono WAV consumed by transcription/VAD/FA
-    model_input_hash: str             # Content hash over that WAV
-    segment_path: Optional[str] = None  # Source-codec cut file (archival pointer)
+    segment_path: Optional[str] = None  # Source-codec cut file (rendition-independent archival pointer)
 
     @property
     def id(self) -> str:  # Deterministic node id
@@ -129,12 +153,11 @@ class AudioSegmentNode:
         return audio_segment_node_id(self.source, self.start, self.end)
 
     def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
-        """Build the AudioSegment node wire dict."""
+        """Build the AudioSegment node wire dict (hashless boundary; sources empty)."""
         props: Dict[str, Any] = {
             "index": self.index,
             "start": self.start,
             "end": self.end,
-            "model_input_path": self.model_input_path,
             "source_id": self.source,
         }
         if self.segment_path:
@@ -143,27 +166,73 @@ class AudioSegmentNode:
             "id": self.id,
             "label": TranscriptGraphLabels.AUDIO_SEGMENT,
             "properties": props,
+            "sources": [],
+        }
+
+# %% ../nbs/schema.ipynb #c97ae502
+@dataclass
+class AudioRenditionNode:
+    """A model-input rendition OF an AudioSegment — the materialized 16k-mono WAV
+    consumed by transcription/VAD/FA. OWNS the model-input (E14: the audio of
+    record); the AudioSegment above it is a hashless boundary.
+
+    Identity = (audio segment, preprocessing chain). The raw convert-only path is
+    an empty chain (its id is stable + chain-free); vocals isolation / future
+    speech-enhancement are non-empty chains. Raw + vocals are therefore distinct
+    renditions that COEXIST under one AudioSegment — the divergent model-input
+    hash that used to collide the AudioSegment now lives on distinct rendition
+    nodes. Connects UP to its AudioSegment by DERIVED_FROM (it is derived from the
+    segment's audio); the production act is recorded separately by a CR-18
+    `Derivation` event."""
+    audio_segment: str                # Owning AudioSegment node id
+    model_input_path: str             # The 16kHz mono WAV consumed by transcription/VAD/FA
+    model_input_hash: str             # Content hash over that WAV (the rendition's identity-of-record artifact)
+    chain: List[str] = field(default_factory=list)  # Ordered preprocessing-chain descriptors; [] = raw convert-only
+
+    @property
+    def id(self) -> str:  # Deterministic node id
+        """Deterministic node id."""
+        return audio_rendition_node_id(self.audio_segment, self.chain)
+
+    def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
+        """Build the AudioRendition node wire dict (owns the model-input SourceRef)."""
+        props: Dict[str, Any] = {
+            "audio_segment_id": self.audio_segment,
+            "model_input_path": self.model_input_path,
+            "chain": list(self.chain),
+            "is_raw": not self.chain,
+        }
+        if self.chain:
+            props["preprocessing"] = " | ".join(self.chain)  # readable display label (the retired interim property)
+        return {
+            "id": self.id,
+            "label": TranscriptGraphLabels.AUDIO_RENDITION,
+            "properties": props,
             "sources": [SourceRef(locator=FileRef(path=self.model_input_path),
                                   content_hash=self.model_input_hash).to_dict()],
         }
 
+    def derived_edge(self) -> Dict[str, Any]:  # Edge wire dict
+        """DERIVED_FROM edge: this rendition derives from its AudioSegment's audio."""
+        return make_edge(self.id, self.audio_segment, OverlayRelations.DERIVED_FROM)
+
 # %% ../nbs/schema.ipynb #9948f2c5
 @dataclass
 class TranscriptNode:
-    """One transcriber's text for one AudioSegment (per-transcriber variants at
+    """One transcriber's text for one AudioRendition (per-transcriber variants at
     the coarse layer — cross-transcriber divergence lives here, C4/C14)."""
-    audio_segment: str            # Owning AudioSegment node id
+    rendition: str                # Owning AudioRendition node id
     transcriber: str              # Transcriber capability name
     config_hash: str              # Transcriber config hash
     text: str                     # The transcript text (stored ONCE here; fine Segments slice into it)
-    audio_hash: str               # Content hash of the consumed model-input WAV
+    audio_hash: str               # Content hash of the consumed model-input WAV (the rendition's)
     metadata: Dict[str, Any] = field(default_factory=dict)  # Transcriber-reported metadata
     asserted_at: Optional[float] = None  # Derivation timestamp; None = now
 
     @property
     def id(self) -> str:  # Deterministic node id
         """Deterministic node id."""
-        return transcript_node_id(self.audio_segment, self.transcriber, self.config_hash)
+        return transcript_node_id(self.rendition, self.transcriber, self.config_hash)
 
     def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
         """Build the Transcript node wire dict (capability attribution included)."""
@@ -171,7 +240,7 @@ class TranscriptNode:
             "transcriber": self.transcriber,
             "config_hash": self.config_hash,
             "text": self.text,
-            "audio_segment_id": self.audio_segment,
+            "rendition_id": self.rendition,
         }
         if self.metadata:
             props["metadata"] = dict(self.metadata)
@@ -181,14 +250,14 @@ class TranscriptNode:
             "id": self.id,
             "label": TranscriptGraphLabels.TRANSCRIPT,
             "properties": props,
-            "sources": [SourceRef(locator=GraphNodeRef(node_id=self.audio_segment),
+            "sources": [SourceRef(locator=GraphNodeRef(node_id=self.rendition),
                                   content_hash=self.audio_hash,
                                   slice=FullContent("audio")).to_dict()],
         }
 
     def derived_edge(self) -> Dict[str, Any]:  # Edge wire dict
-        """DERIVED_FROM edge: this Transcript derives from its AudioSegment."""
-        return make_edge(self.id, self.audio_segment, OverlayRelations.DERIVED_FROM)
+        """DERIVED_FROM edge: this Transcript derives from its AudioRendition."""
+        return make_edge(self.id, self.rendition, OverlayRelations.DERIVED_FROM)
 
 # %% ../nbs/schema.ipynb #0c830160
 @dataclass
@@ -211,29 +280,30 @@ class TranscriptSliceRef:
 @dataclass
 class SegmentNode:
     """Fine spine member: one VAD chunk — IMMUTABLE audio range + CORRECTABLE
-    text (the immutable-audio/mutable-text spine seam).
+    text (the immutable-audio/mutable-text spine seam). PART_OF its AudioRendition
+    (each rendition has its own fine spine).
 
     Layer-0 `text` is the ACCURACY transcriber's alignment; the designation is
     per-segment provenance, not global config (`text_from` names the
     authoritative Transcript; every transcriber's char range rides
     `text_slices`, the authoritative one included)."""
-    audio_segment: str        # Owning AudioSegment node id
+    rendition: str            # Owning AudioRendition node id
     vad_config_hash: str      # VAD config hash (skeleton identity input)
-    chunk_start: float        # VAD chunk start (chunk-local seconds within the AudioSegment WAV)
+    chunk_start: float        # VAD chunk start (chunk-local seconds within the rendition WAV)
     chunk_end: float          # VAD chunk end (chunk-local seconds)
     index: int                # Source-wide fine-spine index (0-based)
     start_time: float         # Source-coordinate start (navigation)
     end_time: float           # Source-coordinate end
     text: str = ""            # Layer-0 text (accuracy alignment; "" = no aligned words, D14 class)
-    audio_hash: str = ""      # Content hash of the owning AudioSegment's model-input WAV
+    audio_hash: str = ""      # Content hash of the owning rendition's model-input WAV
     source: Optional[str] = None     # Source node id (convenience for direct filters)
     text_from: Optional[str] = None  # Authoritative Transcript node id (None when text is empty)
     text_slices: List[TranscriptSliceRef] = field(default_factory=list)  # All per-transcriber slice refs
 
     @property
     def id(self) -> str:  # Deterministic node id
-        """Deterministic node id (audio-side identity; shared across transcribers)."""
-        return segment_node_id(self.audio_segment, self.vad_config_hash,
+        """Deterministic node id (audio-side identity; shared across transcribers, per-rendition)."""
+        return segment_node_id(self.rendition, self.vad_config_hash,
                                self.chunk_start, self.chunk_end)
 
     def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
@@ -245,13 +315,13 @@ class SegmentNode:
             "end_time": self.end_time,
             "chunk_start": self.chunk_start,
             "chunk_end": self.chunk_end,
-            "audio_segment_id": self.audio_segment,
+            "rendition_id": self.rendition,
         }
         if self.source:
             props["source_id"] = self.source
         if self.text_from:
             props["text_from"] = self.text_from
-        sources = [SourceRef(locator=GraphNodeRef(node_id=self.audio_segment),
+        sources = [SourceRef(locator=GraphNodeRef(node_id=self.rendition),
                              content_hash=self.audio_hash,
                              slice=TimeSlice(start=self.chunk_start, end=self.chunk_end)).to_dict()]
         sources.extend(ts.to_source_ref() for ts in self.text_slices)

{cjm_transcript_graph_schema-0.0.5 → cjm_transcript_graph_schema-0.0.6/cjm_transcript_graph_schema.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cjm-transcript-graph-schema
-Version: 0.0.5
+Version: 0.0.6
 Summary: Audio-transcript layer schema for context graphs: Source, AudioSegment, Transcript, and Segment nodes with deterministic identity tuples and graph-node mapping, shared by the transcription, decomposition, and correction workflow cores.
 Author-email: "Christian J. Mills" <9126128+cj-mills@users.noreply.github.com>
 License: Apache-2.0
@@ -30,7 +30,7 @@ pip install cjm_transcript_graph_schema
 ## Project Structure
 
     nbs/
-    └── schema.ipynb # The audio-transcript layer schema (where-graph-begins locked layer schema): `Source -> AudioSegment(coarse, owns the model-input WAV) -> Transcript(per-transcriber variants)` emitted by transcription, extended with the fine `Segment` spine by decomposition. Deterministic identity tuples per the stage-5 ratified rule; `Document` from the pre-CR-18 era dissolves into `Source`.
+    └── schema.ipynb # The audio-transcript layer schema (where-graph-begins locked layer schema): `Source -> AudioSegment(coarse boundary) -> AudioRendition(model-input: raw | vocals | …) -> Transcript(per-transcriber variants)` emitted by transcription, extended with the fine `Segment` spine (per-rendition) by decomposition. Deterministic identity tuples per the stage-5 ratified rule; the `AudioRendition` node lets raw + preprocessed model-inputs of one boundary coexist in one graph. `Document` from the pre-CR-18 era dissolves into `Source`.
 
 Total: 1 notebook
 
@@ -55,10 +55,12 @@ Detailed documentation for each module in the project:
 
 > The audio-transcript layer schema (where-graph-begins locked layer
 > schema):
-> `Source -> AudioSegment(coarse, owns the model-input WAV) -> Transcript(per-transcriber variants)`
-> emitted by transcription, extended with the fine `Segment` spine by
-> decomposition. Deterministic identity tuples per the stage-5 ratified
-> rule; `Document` from the pre-CR-18 era dissolves into `Source`.
+> `Source -> AudioSegment(coarse boundary) -> AudioRendition(model-input: raw | vocals | …) -> Transcript(per-transcriber variants)`
+> emitted by transcription, extended with the fine `Segment` spine
+> (per-rendition) by decomposition. Deterministic identity tuples per
+> the stage-5 ratified rule; the `AudioRendition` node lets raw +
+> preprocessed model-inputs of one boundary coexist in one graph.
+> `Document` from the pre-CR-18 era dissolves into `Source`.
 
 #### Import
 
@@ -67,10 +69,12 @@ from cjm_transcript_graph_schema.schema import (
     TranscriptGraphLabels,
     source_node_id,
     audio_segment_node_id,
+    audio_rendition_node_id,
     transcript_node_id,
     segment_node_id,
     SourceNode,
     AudioSegmentNode,
+    AudioRenditionNode,
     TranscriptNode,
     TranscriptSliceRef,
     SegmentNode
@@ -95,36 +99,60 @@ def audio_segment_node_id(
     """
     AudioSegment identity = (source, boundary range).
     
-    Conversion-config-independent: the model-input WAV is payload/provenance,
-    not identity — the boundary computation is pure and deterministic, so
-    re-derivation reproduces the id.
+    Rendition-independent by design: an AudioSegment is a BOUNDARY of the source
+    (an audio fact), shared across every model-input rendition of it. The
+    boundary computation is pure and deterministic, so re-derivation reproduces
+    the id; the model-input WAV lives on the `AudioRendition` child, not here.
     """
 ```
 
 ``` python
-def transcript_node_id(
+def audio_rendition_node_id(
     audio_segment_id: str,  # Owning AudioSegment node id
-    transcriber: str,       # Transcriber capability name (e.g. "cjm-transcription-plugin-whisper")
-    config_hash: str,       # Transcriber config hash
+    chain: List[str],       # Ordered preprocessing-chain descriptors; [] = the raw convert-only rendition
+) -> str:  # Deterministic AudioRendition node id
+    """
+    AudioRendition identity = (audio segment, preprocessing chain).
+    
+    A rendition is one model-input audio OF an AudioSegment. The chain is the
+    ordered list of preprocessing steps that produced it (each an opaque
+    descriptor string, e.g. ``"source_separation:cjm-media-plugin-demucs@<cfg>"``);
+    an EMPTY chain is the raw convert-only rendition, whose id is therefore
+    stable and chain-free. The universal 16k-mono resample is implicit (not a
+    chain step) — so raw + vocals are distinct renditions under one shared
+    AudioSegment, and the layer's identity-mismatch check never collides them.
+    Re-derivable from the manifest chain alone (extenders recompute, never
+    search).
+    """
+```
+
+``` python
+def transcript_node_id(
+    rendition_id: str,  # Owning AudioRendition node id
+    transcriber: str,   # Transcriber capability name (e.g. "cjm-transcription-plugin-whisper")
+    config_hash: str,   # Transcriber config hash
 ) -> str:  # Deterministic Transcript node id
     """
-    Transcript identity = (audio segment, transcriber, config) — MIRRORS the
+    Transcript identity = (audio rendition, transcriber, config) — MIRRORS the
     capability cache key UNIQUE(audio_path, config_hash), so the graph node is
-    the durable face of the cached row (the structural E13 fix).
+    the durable face of the cached row (the structural E13 fix). Keyed on the
+    RENDITION, so a raw vs vocals transcript of the same boundary are distinct.
     """
 ```
 
 ``` python
 def segment_node_id(
-    audio_segment_id: str,  # Owning AudioSegment node id
-    vad_config_hash: str,   # VAD capability config hash (skeleton identity input)
-    chunk_start: float,     # VAD chunk start (chunk-local seconds within the AudioSegment)
-    chunk_end: float,       # VAD chunk end (chunk-local seconds)
+    rendition_id: str,     # Owning AudioRendition node id
+    vad_config_hash: str,  # VAD capability config hash (skeleton identity input)
+    chunk_start: float,    # VAD chunk start (chunk-local seconds within the rendition WAV)
+    chunk_end: float,      # VAD chunk end (chunk-local seconds)
 ) -> str:  # Deterministic Segment node id
     """
-    Fine Segment identity = audio-side only (audio segment, VAD config, chunk
+    Fine Segment identity = audio-side only (audio rendition, VAD config, chunk
     range) — so the skeleton's ids are SHARED across transcribers by
-    construction (C4 "store agreement once" falls out of identity design).
+    construction (C4 "store agreement once" falls out of identity design). Keyed
+    on the RENDITION: each rendition has its own fine spine (vocals isolation can
+    yield different VAD chunk boundaries than raw).
     """
 ```
 
@@ -166,23 +194,23 @@ class SourceNode:
 @dataclass
 class AudioSegmentNode:
     """
-    Coarse ~5-min spine member. Owns the model-input WAV (E14: the audio of
-    record) as payload/provenance — the WAV is NOT its own node.
+    Coarse ~5-min spine member: a BOUNDARY range of the Source (an audio fact),
+    shared across every model-input rendition of it.
     
-    Provenance note (deliberate): the SourceRef anchors the owned model-input
-    WAV artifact (hash_file-verifiable). A hash over the sliced ORIGINAL source
-    bytes is not materializable without extracting per-range artifacts (decoded
-    ranges are not byte ranges); the structural chain to the Source rides the
-    PART_OF edge + the start/end properties.
+    Hashless by design: a boundary is not a materialized artifact — a hash over
+    the sliced ORIGINAL source bytes is not materializable without extracting
+    per-range artifacts (decoded ranges are not byte ranges). The materialized
+    model-input WAV lives on the `AudioRendition` child (which carries its
+    content hash); the structural chain to the Source rides the PART_OF edge +
+    the start/end properties. `segment_path` (the source-codec cut) stays here as
+    a rendition-independent archival pointer.
     """
     
     source: str  # Owning Source node id
     index: int  # Position in the coarse spine (0-based)
     start: float  # Boundary start (source-coordinate seconds)
     end: float  # Boundary end (source-coordinate seconds)
-    model_input_path: str  # The 16kHz mono WAV consumed by transcription/VAD/FA
-    model_input_hash: str  # Content hash over that WAV
-    segment_path: Optional[str]  # Source-codec cut file (archival pointer)
+    segment_path: Optional[str]  # Source-codec cut file (rendition-independent archival pointer)
     
     def id(self) -> str:  # Deterministic node id
             """Deterministic node id."""
@@ -192,30 +220,69 @@ class AudioSegmentNode:
         "Deterministic node id."
     
     def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
-            """Build the AudioSegment node wire dict."""
+            """Build the AudioSegment node wire dict (hashless boundary; sources empty)."""
             props: Dict[str, Any] = {
-        "Build the AudioSegment node wire dict."
+        "Build the AudioSegment node wire dict (hashless boundary; sources empty)."
+```
+
+``` python
+@dataclass
+class AudioRenditionNode:
+    """
+    A model-input rendition OF an AudioSegment — the materialized 16k-mono WAV
+    consumed by transcription/VAD/FA. OWNS the model-input (E14: the audio of
+    record); the AudioSegment above it is a hashless boundary.
+    
+    Identity = (audio segment, preprocessing chain). The raw convert-only path is
+    an empty chain (its id is stable + chain-free); vocals isolation / future
+    speech-enhancement are non-empty chains. Raw + vocals are therefore distinct
+    renditions that COEXIST under one AudioSegment — the divergent model-input
+    hash that used to collide the AudioSegment now lives on distinct rendition
+    nodes. Connects UP to its AudioSegment by DERIVED_FROM (it is derived from the
+    segment's audio); the production act is recorded separately by a CR-18
+    `Derivation` event.
+    """
+    
+    audio_segment: str  # Owning AudioSegment node id
+    model_input_path: str  # The 16kHz mono WAV consumed by transcription/VAD/FA
+    model_input_hash: str  # Content hash over that WAV (the rendition's identity-of-record artifact)
+    chain: List[str] = field(...)  # Ordered preprocessing-chain descriptors; [] = raw convert-only
+    
+    def id(self) -> str:  # Deterministic node id
+            """Deterministic node id."""
+            return audio_rendition_node_id(self.audio_segment, self.chain)
+    
+        def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
+        "Deterministic node id."
+    
+    def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
+            """Build the AudioRendition node wire dict (owns the model-input SourceRef)."""
+            props: Dict[str, Any] = {
+        "Build the AudioRendition node wire dict (owns the model-input SourceRef)."
+    
+    def derived_edge(self) -> Dict[str, Any]:  # Edge wire dict
+        "DERIVED_FROM edge: this rendition derives from its AudioSegment's audio."
 ```
 
 ``` python
 @dataclass
 class TranscriptNode:
     """
-    One transcriber's text for one AudioSegment (per-transcriber variants at
+    One transcriber's text for one AudioRendition (per-transcriber variants at
     the coarse layer — cross-transcriber divergence lives here, C4/C14).
     """
     
-    audio_segment: str  # Owning AudioSegment node id
+    rendition: str  # Owning AudioRendition node id
     transcriber: str  # Transcriber capability name
     config_hash: str  # Transcriber config hash
     text: str  # The transcript text (stored ONCE here; fine Segments slice into it)
-    audio_hash: str  # Content hash of the consumed model-input WAV
+    audio_hash: str  # Content hash of the consumed model-input WAV (the rendition's)
     metadata: Dict[str, Any] = field(...)  # Transcriber-reported metadata
     asserted_at: Optional[float]  # Derivation timestamp; None = now
     
     def id(self) -> str:  # Deterministic node id
             """Deterministic node id."""
-            return transcript_node_id(self.audio_segment, self.transcriber, self.config_hash)
+            return transcript_node_id(self.rendition, self.transcriber, self.config_hash)
     
         def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
         "Deterministic node id."
@@ -226,7 +293,7 @@ class TranscriptNode:
         "Build the Transcript node wire dict (capability attribution included)."
     
     def derived_edge(self) -> Dict[str, Any]:  # Edge wire dict
-        "DERIVED_FROM edge: this Transcript derives from its AudioSegment."
+        "DERIVED_FROM edge: this Transcript derives from its AudioRendition."
 ```
 
 ``` python
@@ -252,7 +319,8 @@ class TranscriptSliceRef:
 class SegmentNode:
     """
     Fine spine member: one VAD chunk — IMMUTABLE audio range + CORRECTABLE
-    text (the immutable-audio/mutable-text spine seam).
+    text (the immutable-audio/mutable-text spine seam). PART_OF its AudioRendition
+    (each rendition has its own fine spine).
     
     Layer-0 `text` is the ACCURACY transcriber's alignment; the designation is
     per-segment provenance, not global config (`text_from` names the
@@ -260,26 +328,26 @@ class SegmentNode:
     `text_slices`, the authoritative one included).
     """
     
-    audio_segment: str  # Owning AudioSegment node id
+    rendition: str  # Owning AudioRendition node id
     vad_config_hash: str  # VAD config hash (skeleton identity input)
-    chunk_start: float  # VAD chunk start (chunk-local seconds within the AudioSegment WAV)
+    chunk_start: float  # VAD chunk start (chunk-local seconds within the rendition WAV)
     chunk_end: float  # VAD chunk end (chunk-local seconds)
     index: int  # Source-wide fine-spine index (0-based)
     start_time: float  # Source-coordinate start (navigation)
     end_time: float  # Source-coordinate end
     text: str = ''  # Layer-0 text (accuracy alignment; "" = no aligned words, D14 class)
-    audio_hash: str = ''  # Content hash of the owning AudioSegment's model-input WAV
+    audio_hash: str = ''  # Content hash of the owning rendition's model-input WAV
     source: Optional[str]  # Source node id (convenience for direct filters)
     text_from: Optional[str]  # Authoritative Transcript node id (None when text is empty)
     text_slices: List[TranscriptSliceRef] = field(...)  # All per-transcriber slice refs
     
     def id(self) -> str:  # Deterministic node id
-            """Deterministic node id (audio-side identity; shared across transcribers)."""
-            return segment_node_id(self.audio_segment, self.vad_config_hash,
+            """Deterministic node id (audio-side identity; shared across transcribers, per-rendition)."""
+            return segment_node_id(self.rendition, self.vad_config_hash,
                                    self.chunk_start, self.chunk_end)
     
         def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
-        "Deterministic node id (audio-side identity; shared across transcribers)."
+        "Deterministic node id (audio-side identity; shared across transcribers, per-rendition)."
     
     def to_graph_node(self) -> Dict[str, Any]:  # Node wire dict
             """Build the Segment node wire dict (audio ref + per-transcriber text slice refs)."""

cjm_transcript_graph_schema-0.0.5/cjm_transcript_graph_schema/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.0.5"