yemaya library

The official TypeScript/JavaScript SDK (libs/yemaya/sdk/src, layer:clients): a YemayaClient with ProjectContext, typed config (timeouts/retries/rate limits), Zod schemas for projects/assets/scenes/characters/generations, plus hooks, resources, and advanced modules. The in-repo client surface for the platform API.

The official C++ SDK (libs/yemaya/sdk-cpp/src, lang:cpp). A CMake-built (C++17, OpenSSL for HTTPS) client library with resources/ and configurable test/example/docs build options per its README — the native client surface for the platform.

The official Python SDK (libs/yemaya/sdk-python/src/yemaya, language:python): sync (client.py) and async (async_client.py) clients, config, http, exceptions, a cli, and generated gRPC stubs under proto/ (agent, ai, asset, auth, …). A real Python package (pip install yemaya) per its README, not a binding stub.

Shared branded primitives and result helpers for all Yemaya packages (libs/yemaya/types/src/index.ts, ~28 lines, tagged scope:shared, layer:contracts). Defines AssetID/ProjectID/AgentID brands and the Result<T> / Success / Failure discriminated union the rest of the area returns from. Tiny but foundational — it sits at the bottom of the dependency graph.

The data layer (libs/yemaya/database/src, layer:data): re-exports a generated Prisma client (src/generated/client) and typed models for users, orgs, teams, projects, asset library, activity, billing, and the plugin marketplace. The header documents the deliberate split — capability-domain models live in @isis/database, @hathor/database, @sophia/database, @bellona/database, leaving this package the platform spine.

The multi-agent framework and by far the largest library here (~560 source files across 30+ feature areas: base, registry, queue, orchestration, planning, npc-ai, procedural-animation, quality-assurance, hitl, scaling, plus bellona-/hathor-/isis-/sophia-integration). The barrel exposes runtime primitives (BaseAgent, SimpleAgent, AgentRegistry, TaskQueue, DeadLetterQueue) as named exports and the large feature areas as namespaces. Multi-agent orchestration described in the header as LangGraph/CrewAI-style.

Curated asset views, packaging, and distribution (libs/yemaya/asset-library/src, barrel over schemas/, services/, security/, processing/, and a lineage/living-scene/ module). The higher-level library/distribution layer on top of @yemaya/assets, including a Living-Scenes lineage hook.

Digital asset management (libs/yemaya/assets/src, ~40 source files across storage/, versioning/, metadata/, indexing/, search/, diff/, cdn/, database/). The platform's asset record/version/tag/relationship/collection model plus search and storage — the canonical asset store the rest of the area reads and writes.

Concrete end-to-end pipeline implementations (libs/yemaya/autonomous-pipelines/src/pipelines/): film.ts, game.ts, qc.ts, curation.ts, and an mcp-step.ts. A thin barrel over five real pipeline modules — the production-specific recipes the orchestration engine runs.

Living-Scenes transition contracts (libs/yemaya/blend-kernel/src): a typed TRANSITION_KINDS set (latent-warm-start, optical-flow-morph, color-lut-match, audio-crossfade, narrative-pivot, motion-descriptor handoff/reset) plus catalog/ (cinematographic catalog + tone-gating), a compatibility/ scorer with override audit, and continuity-evals/. Honestly scoped: it owns the contracts and parameter validation; the file header states the actual DSP/shader implementations live downstream.

Real-time collaboration hub (libs/yemaya/collaboration/src): CRDT document sync (DocumentManager/CRDTDocumentManager with in-memory providers), presence (PresenceManager, PresenceTracker with cursor/selection and user colors), plus session, sync, voice, integrations, and advanced sub-modules. Presence, sync, and communication for multi-user editing.

Community platform (libs/yemaya/community/src): managers for forums (ForumManager), project showcases, tutorials, educational resources, and a certification program, each with an in-memory storage provider and injectable moderation/notification/proctoring seams. The social/learning layer around Yemaya.

Dailies ingestion and review (libs/yemaya/dailies-review/src/index.ts, ~112 lines). Exposes a focused capability set: ingest plans, ingestion pipelines, proxy generation, automatic sound-sync plans, viewing-color application, metadata preservation, and editorial delivery (createDailiesIngestPlan, createAutomaticSoundSyncPlan, createEditorialDeliveryPlan, etc.).

Enterprise features (libs/yemaya/enterprise/src, package @yemaya/enterprise): deployment (multi-cloud targets, K8s-style resource/network/scaling/health configs), pipeline automation, custom model training, analytics, and integrations, plus advanced/utils. The enterprise-deployment and ops surface of the platform.

The Living-Scenes runtime (libs/yemaya/living-scenes-runtime/src, ~57 source files, one of the larger libraries). Barrel over many sub-systems: score, conductor, safety, determinism, envelope, cues/cue-privacy, provenance, shareability, takedown, release-gates, compose-assist, customer-card, personal-artifacts, plus a segment-adapter. Notably uses @noble/hashes/sha2 (not node:crypto) so the envelope/privacy/artifact paths are client-bundle-safe. The runtime that drives interactive, personalized scenes.

Unified marketplace (libs/yemaya/marketplace/src, ~33 source files) combining three verticals exposed as namespaces: asset (3D models/textures/audio with listings, licensing, transactions, carts, reviews, seller analytics), plugin (extensions/tools), and ai-model (model cards/fine-tunes), over a common utility layer. Listings, licensing, and transaction logic for all three.

Pipeline execution and workflow coordination (libs/yemaya/orchestration/src, with schemas/, services/, execution/). The execution/ directory carries real coordinators — director, dispatcher, pipeline-runner, htn-translator (hierarchical task networks), quality-loop, retry-manager, budget-manager, hitl-judge-evidence, and an mcp-client-facade — i.e. the engine that turns a plan into dispatched, quality-gated, budgeted work.

Pre-production tooling (libs/yemaya/pre-production/src/index.ts, ~861 lines). Includes a Fountain screenplay model (typed FountainElementType, title-page entries, element metadata) — i.e. screenplay parsing/representation and related pre-production structures. A single substantial module rather than sub-directories.

Project, workspace, folder, and versioning management (libs/yemaya/projects/src, barrel over schemas/ and services/). The project-management domain model — the platform's notion of a project and its workspace/folder/version structure.

A standalone Rust crate (libs/yemaya/rendering-pipelines/crates/yemaya-raster-gpu, no TS sourceRoot) that mirrors the CPU raster kernel in wgpu/WGSL: a premultiplied source-over compositor with all twelve separable blend modes (COMPOSITE_OVER_WGSL) and a separable edge-clamped Gaussian blur (GAUSSIAN_BLUR_WGSL). Default build pulls only naga to validate the shaders headlessly; the real dispatch path is behind a gpu cargo feature needing an adapter at runtime — honestly gated rather than faked.

Robotic capture-mannequin control (libs/yemaya/remote-film-mannequin/src, ~18 modules): hardware, pose presets, body adjustment, force feedback, facial display, clothing surface, a safety system, space calibration, portable design, power management, motion driving, low-latency motion streaming, a motion-safety filter, advanced motion, interaction replacement, and Galatea integration. The hardware abstraction for a remote stand-in actor.

AI safety and content governance (libs/yemaya/safety/src, with ethics/ and filtering/). Prompt-safety checking, content review/flagging, consent management, bias detection, and attribution tracking, with branded ID types (SafetyCheckId, ContentFlagId, ConsentRecordId, BiasReportId, etc.).

Diagram rendering (libs/yemaya/diagram-renderer/src): diagram-core, layout-engine, svg-renderer, an accessibility-generator, and a diagram-factory, with branded IDs for diagrams/nodes/edges/layouts. Produces accessible SVG diagrams.

Presentation/slide-deck compilation (libs/yemaya/presentation-compiler/src): slide-core, layout-engine, theme-manager, export-engine, and a presentation-factory, with branded presentation/slide/element/theme IDs. Compiles structured content into themed, exportable presentations.

Text-to-speech integration (libs/yemaya/tts-integration/src): tts-core, voice-manager, ssml-engine, audio-pipeline, a tts-factory, and a real CPU local-engine sub-module (per prior work, espeak-ng/Piper). Turns scripts into voiced audio.

Core platform logic and utilities (libs/yemaya/core/src/index.ts, ~1088 lines, tagged scope:shared, layer:infra). Provides the Result constructors and guards (success, failure, isSuccess, isFailure, unwrap) over @yemaya/types, plus advanced, config, and encryption sub-modules. The shared infra spine other Yemaya libraries build on.

The inbound counterpart (libs/yemaya/event-handlers/src, layer:integration): registers handlers for events from other domains — handleIsisAssetGenerated, handleIsisJobFailed, handleSophiaDocumentIngested, handleHathorWorldPublished, handleBellonaBuildCompleted, handleBellonaExportReady — against the shared @oshun/event-bus IEventBus. This is how Yemaya reacts to capability-domain work.

The shared React UI component library (libs/yemaya/ui/src, layer:ui; the components/ directory alone holds ~123 .tsx components, with a11y, i18n, pwa, theme, styles, and utils sub-systems). A large, real design-system — buttons, icon buttons, button groups, link buttons, and far beyond — consumed by Yemaya's front-ends.

JWT-based authentication (libs/yemaya/auth/src, ~44 source files under services/, oauth/, middleware/). Real implementations: JWT generation/ validation, OAuth2 providers (Google, GitHub, Discord, Apple, Microsoft), Redis-backed sessions, Argon2 password hashing, token blacklisting, and Hono auth middleware (createJWTService, createOAuthService, createAuthMiddleware).

Type-safe cross-domain event publishing for Yemaya (libs/yemaya/event-publisher/src/yemaya-event-publisher.ts). Exposes YemayaEventPublisher plus a singleton accessor, with strongly-typed payloads for project/member/asset/comment/session lifecycle events (YemayaProjectCreatedPayload, YemayaAssetUploadedPayload, etc.) that other domains subscribe to on the bus.

A very large remote-capture / computer-vision pipeline (libs/yemaya/remote-film-capture/src, ~208 source files, flat module layout). The barrel re-exports a full remote-shoot stack: hardware detection and setup, camera/color/room calibration; a deep segmentation/matting suite (background segmentation, temporal coherence, fine-detail matting, chroma-keying, hybrid segmentation, quality scoring); pose/face/hand/gaze tracking; relighting and image restoration (super-resolution, denoise, rolling-shutter, white balance, frame interpolation); production audio (voice capture, dialogue mixing, ADR workflows, binaural/ambisonics); scheduling, equipment/inventory, budgeting, and human-AI co-direction. Cross-domain Aphrodite integration barrels are intentionally not re-exported (commented out in the barrel) — an honest boundary.

Procedural/AI asset generation (libs/yemaya/asset-generation/src): asset-core (resolution/format/DPI presets, SeededRandom, dimension math), asset-factory, illustration-engine, thumbnail-generator, and media-assembler. Deterministic sizing/format logic plus generation orchestration.

Audio-video synchronization (libs/yemaya/av-sync/src): a timing-core with timebase/timestamp math (PTS↔seconds, samples↔frames), a frame-synchronizer, a drift-corrector, a waveform-analyzer, and an av-sync-factory. Real timing arithmetic for keeping audio and video aligned.

Autonomous budget and resource management (libs/yemaya/budget-management/src): substantial compute-budget.ts (~280 lines), timeline-management.ts (~705), and optimization.ts (~502) for quality/budget/time tradeoffs. Real algorithmic code, not a scaffold; the header dates it to Phase 26.4.

Canon/continuity enforcement (libs/yemaya/canon-enforcement/src/canon-manager.ts, ~742 lines + types, with canon-enforcement.test.ts and visual-consistency.test.ts). Keeps generated content consistent with established canon — a real CanonManager, distinct from the V8 yemaya-canon-graph.

V8 "Ariadne" Palimpsest — the continuity knowledge graph that grounds every generated case (libs/yemaya/canon-graph/src). Real implementations: a typed CanonGraph node/edge model, a feature-hashing embedder + TF-IDF index with a hybrid SCORE-style retriever (retrieve, hybridScore), a G7 consistency check (checkConsistency), content-hash snapshots (snapshotHash, makeSnapshot), outcome write-back (commitOutcome), and seedFromV5 to bootstrap from the V5 city. Renamed from "Mnemosyne Canon" to avoid colliding with libs/mnemosyne/*.

"Loom", the asset-realization fabric (libs/yemaya/case-assets/src). Binds a generated case to multimedia through the Isis client: plan exactly which assets a case needs, retrieve from the library and mint only gaps, orchestrate mint jobs fail-loud, bind every url with C2PA provenance, budget-degrade against the case budget, cast a stable voices per character, and assemble a metahuman from portrait + persona. The realize entry composes them.

"Daedalus", the compile core (libs/yemaya/case-compiler/src). Compiles a verified MysterySession (+ AssetManifest) into the shipping V5 FV5* structs and a v2 cold_cases_manifest.json pack with a resolved asset bundle (context, evidence, deductions, accusations, pack, bundle, compile), gated by validate-cold-cases.py. The apps/v8/daedalus-compiler CLI is a thin wrapper over this lib.

The shared data contracts for the V8 case sub-system (libs/yemaya/case-contracts/src): the three IRs (CaseSpec, CaseGroundTruth, the MysterySession IR), the V5 compile target (v5-target), plus the cross-cutting spines — journal, budget, asset-manifest, manifest, compiled-case, canon-context. Pure contracts that let the pipeline stages be built and verified in parallel.

"Oracle", the open-world case director (libs/yemaya/case-director/src). Models each player (player-model), keeps a mint-queue of warm verified cases against a budget, decides world placement, pacings difficulty/theme while weaving open canon threads, and schedules seasonal weekly cold-case drops (with deterministic rng) that replace V5's authored packs.

"Clew", the solve-first generative case engine (libs/yemaya/case-engine/src). Deterministically builds the symbolic skeleton — truth-weaver, clue-smith, timeline, profiles, a constraint network, and an llm-proposer seam — so that by construction exactly one suspect satisfies the player-available clues. The LLM proposes; the solver disposes.

"Theseus", the automated playtester and eval gates (libs/yemaya/case-eval/src): an autonomous solver over the compiled V5 data for G4 in-game solvability, a G5 LLM-as-judge 8-dimension quality panel (judge) aggregated by pca, calibration, a regression corpus harness, and the seven-gate release ReleaseDecision.

V8 localization and accessibility (libs/yemaya/case-localization/src): localize (per-locale text over a locale-invariant deduction core, §11.7) and accessibility (captions, colourblind-safe evidence cues, progressive difficulty hints, dyslexia-friendly text, §11.8). A focused two-module library extending the V6/V7 loc regimes.

The V8 cross-cutting pipeline primitives every stage shares (libs/yemaya/case-pipeline/src): the per-case + three-tier mint budget, the event/journal spine, determinism/replay, C2PA provenance, the G6 safety seam, the hitl review queue, co-op canon multiplayer writeback arbitration, live telemetry/drift detection, and a loadtest mint-throughput harness.

The "Ori-Detective" living-suspects runtime (libs/yemaya/case-suspects/src). Each suspect carries a generative-agent mind (SuspectOri) with a memory stream (reflection + planning, Park et al.), an injectable DialogueBackend (live via a hathor-adapter or a deterministic offline voice), a fair-lying guard enforcing at runtime the same covenant Minos enforces at authoring time, a latency system-context cache, and the runtime itself. Fail-closed broker degrades to the offline path with no creds.

"Minos", the solvability and fair-play gate (libs/yemaya/case-verifier/src). Real solvers: a CNF/DPLL SAT core (sat/cnf, sat/dpll) and an asp path for G1 formal uniqueness, G2 deductive completeness, G3 fairplay (Knox/Van-Dine), balance, difficulty grading, a repair critique-revise loop, and a signed report. The gate that proves a generated case is uniquely solvable.

"Anansesɛm", the writers' room (libs/yemaya/case-writers-room/src). Takes a verified case skeleton + CanonContext and realizes the narrative surface via a fan-out dag (Showrunner + five specialist writers + Integrator), with a grounding boundary that forbids inventing suspects/locations, an interrogation realizer aligned to V5's 12 facial-tell beats, scenes, era-voice, and localization-ready strings. Deterministic from (case, seed); an optional CompletionFn enriches prose fail-loud within the grounding boundary.

ComfyUI integration for image generation (libs/yemaya/comfyui-integration/src): workflow-core, node-registry, generation-pipeline, provider-manager, and a comfyui-factory. Builds and runs ComfyUI graphs against image-generation providers.

D3-based chart rendering (libs/yemaya/d3-visualizations/src): chart-core, data-transforms, and concrete bar-chart/line-chart/pie-chart modules, with branded chart/series/axis/legend IDs. Data-visualization primitives for the platform.

Human-in-the-loop override system (libs/yemaya/human-override/src/override-system.ts, ~584 lines + types, with override-system.test.ts). The mechanism by which a human can intercept and redirect autonomous agent decisions.

Educational podcast generation (libs/yemaya/podcast-generator/src): episode-core, script-engine, audio-mixer, content-analyzer, and a podcast-factory. Composes analyzed content into scripted, mixed podcast episodes.

Production artifact verification and sign-off (libs/yemaya/production-verification/src/verification.ts, ~697 lines, with verification.test.ts and artifact-signoff.test.ts). Verifies that produced artifacts meet the production gates before release.

A franchise-specific project library (libs/yemaya/project-obsidian/src/index.ts, ~964 lines) for "Project Obsidian", a near-future (2089) detective-noir franchise spanning a AAA game and a premium TV series on shared canon. Provides typed project setup, configuration, and franchise orchestration (genre/tone/platform/ rating enums, media types, production phases, budget/resource types). A concrete franchise instance built on the platform, not generic infrastructure.

The CPU rendering pipeline (libs/yemaya/rendering-pipelines/src, ~27 source files): raster-kernel (the deterministic reference renderer), render-core, content-renderer, visual-compositor, text-shaping, export-pipeline, and a render-factory. The reference compositor whose pixels the GPU crate mirrors.

The platform's self-improvement loop (libs/yemaya/self-improvement/src/self-improvement.ts, ~845 lines + types). A thin barrel over one substantial module that closes the learn-from-outcomes loop; backed by a self-improvement.test.ts.

Style transfer and brand-consistent restyling (libs/yemaya/style-transfer/src): style-core, brand-manager, transfer-engine (model selection, art-style prompt presets, blending curves, resource-cost tables), a consistency-validator, and a style-factory, with an injectable backend/.

Video generation (libs/yemaya/video-generation/src), described in-header as Hunyuan/WAN: video-core, a model-registry (model definitions, VRAM/budget filtering, findBestModelForUseCase, calculateModelScore), a provider-router, and a video-factory. Model-selection and routing logic for video models.