TriadicFrameworks
Overview

workflows

📘 API reference blocks (scroll‑centric module layout)#

These blocks follow the structure of the Workflows README and the style of your site’s documentation. github.com

batch_orchestrator.py#

batch_run(items, output_dir=None) → dict

items:
    list of .fff file paths, in‑memory scroll objects, or mixed lists

output:
    {
      "timestamp": "...",
      "count": N,
      "results": [
        { "input": ..., "output": ... },
        ...
      ]
    }

remix_generation.py#

remix_scroll(scroll_obj, rules=None) → dict

Produces a remix variant of a scroll object.
Preserves canonical anchors and adds remix metadata.

scroll_pipeline.py (Python)#

run_scroll(scroll_text) → dict

Parses and executes a scroll.
Returns:
    { "output": ..., "warnings": [...], "metadata": {...} }

scrollPipeline.js (JavaScript)#

runScroll(scrollText) → object

Browser‑native scroll execution.
Mirrors the Python pipeline API.

# 🔷 Workflow Diagram (Refreshed, Scroll‑Centric)

This diagram shows how the four workflow engines relate to each other using the updated scroll‑centric topology:

  • Scrolls remain the canonical center
  • Pipelines are execution paths (Python + JS symmetry)
  • Remix generates lineage variants
  • Batch coordinates multi‑scroll execution
  • Engines orbit the scroll artifact, not each other

🔷 Text‑Based Diagram (Single‑Glance)#

                               🔷
                 ┌──────────────────────────┐
                 │   remix_generation.py    │
                 │   (Remix Lineage Engine) │
                 └──────────────▲───────────┘
                                │
                        produces variants
                                │
        ┌───────────────────────┴────────────────────────┐
        │                                                │
        │                Scrolls (.fff)                  │
        │        (canonical RTT artifacts)               │
        │                                                │
        └───────────────────────┬────────────────────────┘
                                │
                         executed by
                                │
 ┌──────────────────────────────┼──────────────────────────────┐
 │                              │                              │
 │     ┌────────────────────┐   │     ┌───────────────────┐    │
 │     │ scroll_pipeline.py │   │     │ scrollPipeline.js │    │
 │     │   (Python Engine)  │   │     │    (JS Engine)    │    │
 │     └────────────────────┘   │     └───────────────────┘    │
 │                              │                              │
 └──────────────────────────────┴───────────────┬──────────────┘
                                                │
                                        executes many
                                                │
                                   ┌──────────────────────────┐
                                   │  batch_orchestrator.py   │
                                   │     (Batch Runner)       │
                                   └──────────────────────────┘

Interpretation#

  • Remix Generation creates new scroll variants.
  • Scroll Pipelines (Python + JS) execute scrolls in different runtime environments.
  • Batch Orchestrator runs many scrolls or variants in sequence.
  • Scrolls remain the invariant center; engines are operators around them.

This matches the modernized architecture shown in your Workflows page and the scroll‑centric Quickstart.

🔷 Updated Triadic Glyph (Scroll‑Centric)#

A glyph for this subsystem should reflect the updated relationships:

                 🌀 Scroll Artifact
        ┌───────────────┼────────────────┬────────────────┐
        │               │                │                │
        │         🌐 JS Pipeline   🐍 Python Pipeline   🎨 Remix Engine
        │               │                │                │
        └───────────────┴────────────────┴────────────────┘
                                ▼
                         📦 Batch Orchestrator

Interpretation#

  • The scroll artifact is the invariant center.
  • Pipelines and Remix orbit horizontally as sibling engines.
  • Batch anchors the system by coordinating multi‑scroll execution.
  • The glyph mirrors the structural relationships in the diagram above.

🔷 Notes for maintainers#

  • /docs/engine/ has been archived; no engine‑era modules appear in this diagram.
  • All workflows now use the scroll‑centric module layout (tft.scrolls.*).
  • Pipelines maintain Python/JS symmetry.
  • Remix and Batch remain orthogonal operators.
    ## ⚡ Quickstart snippets (drop‑in for README or website)

These follow the QUICKSTART style from your site and GitHub docs. github.com

Run a single scroll (Python)#

from scroll_pipeline import run_scroll
 
scroll = """
emitter: demo
frequency: 144
"""
 
result = run_scroll(scroll)
print(result["output"])

Run multiple scrolls (batch orchestrator)#

from batch_orchestrator import batch_run
 
paths = ["scrolls/a.fff", "scrolls/b.fff"]
report = batch_run(paths, output_dir="reports")
 
print(report["count"], "scrolls executed")

Generate a remix variant#

from remix_generation import remix_scroll
 
scroll = """
emitter: demo
frequency: 144
"""
 
variant = remix_scroll(scroll)
print(variant["metadata"]["remix_id"])

Run a scroll in the browser (JS)#

import { runScroll } from "./scrollPipeline.js";
 
const scroll = `
emitter: demo
frequency: 144
`;
 
const result = runScroll(scroll);
console.log(result.output);

These snippets mirror the API shapes of the refreshed engines and match the tone of your existing QUICKSTART docs.

    🌀⚙️📜

Scroll • Engine • Artifact # 🌀⚙️📜 Workflow Engines

Operational layer for RTT‑Inside: batches, pipelines, and remix generation#

This directory contains lightweight, substrate‑agnostic workflow modules used across TriadicFrameworks for scroll generation, batch execution, remix lineage creation, and resonance‑aware pipeline orchestration.

Each workflow is intentionally minimal: no external dependencies, no hidden state, and no assumptions about the host environment. They are designed to be portable, inspectable, and safe to remix.

🗂️ Index Card#

Lightweight, substrate‑agnostic execution tools for scrolls, batches, and remix lineages.

  • 📦 Batch Orchestrator — deterministic multi‑scroll execution
  • 🎨 Remix Generator — lineage‑safe remix creation
  • 🌐 Scroll Pipeline (JS) — browser‑native execution path
  • 🐍 Scroll Pipeline (Python) — programmatic scroll engine

These engines form the operational layer of RTT‑Inside, bridging scroll artifacts with executable pipelines across languages and environments.

📁 Contents of workflows folder#

🛤️ corridor_batch_validator.py#

Corridor‑level batch validator using RTT‑QEB primitives.

  • Fetches corridor metadata
  • Normalizes rail signatures
  • Computes RCI and glyph
  • Compares against stored metadata
  • Emits a timestamped YAML validation report

📦 batch_orchestrator.py#

A scroll‑centric batch runner for executing multiple .fff artifacts through the Python scroll pipeline.

  • Accepts file paths, in‑memory scroll objects, or mixed lists
  • Loads and normalizes scrolls when needed
  • Executes each scroll via scroll_pipeline.py
  • Captures outputs, lineage metadata, and warnings
  • Aggregates results into a deterministic batch report
  • Optionally writes a timestamped YAML report for archival or analysis

This engine is substrate‑agnostic and forms the batch‑execution counterpart to the Python and JS scroll pipelines.

🎨 remix_generation.py#

A remix‑lineage generator that produces new scroll variants from a base artifact.

  • Applies remix rules from TFT_3Pack
  • Preserves canonical anchors (τᵣ, D3/D6/D9, emitter constants)
  • Generates remix metadata blocks for downstream tools
  • Ideal for student remix submissions or experimental scroll forks

🌐 scrollPipeline.js#

A JavaScript‑based scroll pipeline for browser‑side or lightweight client execution.

  • Runs resonance flows without Python
  • Integrates with rtt.js and site‑level overlays
  • Useful for interactive demos, web‑native scroll previews, and teaching tools

🐍 scroll_pipeline.py#

The Python counterpart to the JS pipeline.

  • Provides a stable API for scroll parsing, validation, and execution
  • Supports .fff format operations
  • Can be embedded into notebooks, CLI tools, or batch systems

🔧 Purpose of This Folder#

The workflows directory acts as the operational layer of TriadicFrameworks:

  • A place for small, composable engines
  • A bridge between RTT theory and practical execution
  • A toolkit for students, developers, and researchers working with scrolls, .fff files, or resonance‑aware pipelines
  • A foundation for future integrations (AI drift calibration, substrate‑mind science, dimensional‑core validators)

These workflows intentionally avoid domain‑specific assumptions so they can run across the entire TriadicFrameworks ecosystem.

🧩 Relationship to TFT_3Pack v1.3#

These workflows complement the tools found in:

/docs/TFT_3Pack_v1.3/scripts/
/docs/TFT_3Pack_v1.3/tft/
/docs/TFT_3Pack_v1.3/examples/

Where TFT_3Pack provides formats, examples, and shell tools, the /workflows/ folder provides programmable engines for:

  • Batch processing
  • Scroll remixing
  • Pipeline execution
  • Cross‑language integration (Python ↔ JS)

Together, they form the execution backbone of RTT‑Inside.

🧭 When to Use These Workflows#

Use this folder when you need:

  • To run multiple scrolls in sequence
  • To generate remix lineages
  • To embed scroll execution into a Python or JS project
  • To validate .fff files programmatically
  • To build new tools on top of RTT‑Inside primitives

🗺️ Future Extensions#

Planned additions include:

  • Regime‑aware pipeline overlays
  • Scroll‑to‑TFT converters
  • AI‑drift‑resilient execution wrappers
  • Dimensional‑core validators
  • Cross‑ontology translators

These will follow the same principles: minimal, portable, remix‑friendly. 

Powered by Docsbook