Emblema Official

// Reads one Drive file exactly as it was uploaded (a PDF, a PowerPoint or Word file, an image, an archive or any other type) and outputs it as a File, for nodes that take the file itself rather than its text: e.g. Snapshot, to turn a PDF into page images. Also outputs its MIME type and size. For the text of a document or a transcript, use Drive Content Reader instead.

// Publishes a customer PowerPoint master (.pptx or .potx from Drive) as this workspace's layout library. Extracts every layout with its slots, capacities and theme, applies the curator's layout curation, renders each layout's background through document-render, and outputs the library handle, the enabled layouts as a compact text list for choosing each slide's layout, the catalog, the master normalized to .pptx, and the background and thumbnail images. A deck in this workspace wires Library, Master and Backgrounds straight to its slide nodes; a deck elsewhere reads the library through a Layout Library. The library is this node's latest completed run; a failed run keeps the previous one. One Brand Master per workspace.

// Reads the layout library a Brand Master node publishes in another workspace: that node's latest completed run. Outputs the library handle (the enabled layouts with their slots and capacities, plus the library CSS) for Slide Generators, the Presentation Composer and the PPTX Builder, the master as a .pptx file, the layout backgrounds, and the enabled layouts as a compact text list for choosing each slide's layout. Run it again to pick up the curator's latest publication.

// Save a workspace file or text into a Drive folder

// Reads all documents from a Drive folder recursively. Returns document references that can be passed to a Drive Content Reader. Also returns every file with its sub-folder path, so a loop can save results into the same sub-folders elsewhere.

// Translates one Drive document into another language keeping its page layout (columns, tables, figures) and returns a translated PDF, a bilingual PDF for review (each original page beside its translation, on by default), and a report. Word, PowerPoint and text uploads are translated from the PDF Drive made of them, so they also come back as a PDF, never as an editable file. The run succeeds only when every passage is translated and the result passes the checks for leftover untranslated text and changed numbers; otherwise it fails with a clear message naming the problem and the pages, and returns no PDF. An optional Style says in your own words how the translation should read (formal, plain language, technical). Scanned PDFs (no text layer) are refused. Text inside pictures is not translated. For a text-only reading copy, use the Drive Translate menu instead. To keep the result in Drive, connect it to Save File.

// Generates a single presentation slide from text content and an instruction. Connect multiple Slide Generator outputs to a Presentation Composer to build a full presentation.

// Assembles slide sections into a complete presentation. Outputs a self-contained HTML file viewable in any browser. With the Emblema theme, an optional brand kit and logo re-skin the deck in your brand. With a Layout Library connected, the deck takes that library's look and canvas size.

// Turns a designed deck into a PowerPoint master for a brand: every slide of the Presentation Composer's deck becomes one slide layout, its look as the layout background and its title, text, lists, picture, table and slide number as placeholders that keep the slide's fonts, sizes and colours; a preview deck, one slide per layout with its sample text, shows the master as PowerPoint draws it. Design the slides with Slide Generators in layout design mode (a layout name on each), then save the master to Drive and select it in a Brand Master to publish it as a layout library.

// Turns one document into images, one per page, to show, check or pass on page by page. Connect ONE source: a PDF; a PowerPoint (.pptx), drawn by LibreOffice (fonts can differ slightly from PowerPoint, hidden slides are left out); an image (PNG, JPEG, WebP, GIF), passed through as it is; or the Presentation Composer's HTML deck. Width sets how wide each page image is (the height follows the page); Max Pages caps how many pages become images; Pages reports how many pages the source has. For a picture of a 3D model, use 3D Snapshot instead.

// Collects multiple inputs into an ordered array. Add items dynamically and drag to reorder. Carries files through when item ports receive image/video/audio outputs.

// Reads an image from Drive and outputs it as an Image file, plus its metadata: width, height and aspect ratio (EXIF orientation applied, so portrait vs landscape is reliable), MIME type, file size and camera EXIF (make, model, capture time; GPS is never output). Metadata is best-effort: if it cannot be read (e.g. HEIC), the image is still output and Warning says why.

// Converts an HTML presentation into a downloadable PowerPoint (.pptx) file. Connect to a Presentation Composer output.

// Turns a presentation into a PDF to share or print, one page per slide. Connect ONE source: the Presentation Composer's HTML deck, printed as it shows on screen with selectable text; or the PPTX Builder's PowerPoint file, drawn by LibreOffice like its previews (fonts can differ slightly from PowerPoint, hidden slides are left out). The PDF is named after the presentation.

// Synthesizes an answer from multiple document chunks using an LLM. Connect one or more Document Chunk nodes to the context port.

// THE node for 'how is X connected to Y?' (Start X, To Y) and 'what is related to X?' (Start X alone): explained paths through the ontology, each hop cited to its source passage; it can also walk a typed chain of hops. Emits a synthesizer-ready summaryText; wire Start from Merge Ranked Lists' topId and summaryText into a Knowledge Synthesizer's context. Start and To take an entity's NAME only, as the documents write it and never translated ('现金流风险' stays '现金流风险'): the kind the user names goes in Start Type / To Type ('lo strumento AI' is Start 'AI', Start Type 'AI tool'; 'AI (AI_Model)' is Start 'AI', Start Type 'AI_Model'). A result shows 2 paths unless Max Paths raises it (up to 5). Query (advanced) replaces every field, Start included.

// Walk typed links out of, into, or both directions from an ontology object and return the connected sub-graph.

// Builds a PowerPoint file from a composed library presentation by filling the customer's own master: each slide uses its layout from the layout library, with text, bullets, tables, pictures and speaker notes in the layout's placeholders. Every slide is checked against the library first, and the run fails listing every problem by slide and slot. Outputs the .pptx, named after the presentation title, plus PNG previews (optional: if they cannot be rendered the .pptx is still ready).

// One unit of intent, above the lanes that attempt it. Holds the brief and nothing else: wire it into one or more Lane nodes and they share that one text, while the board rolls their states up into a single status for the task. A lane is a worker on a branch — this is the thing the worker is working ON, and it outlives any single attempt.

// Collect the tasks every Plan review produced into one ordered, de-duplicated list. Several reviews wire into its one Tasks input; it drops the duplicates four lenses inevitably raise, sorts by priority then by lens, and emits both the JSON a Task node is built from and the markdown checklist a design doc carries.

// Run one of gstack's plan reviews — spec (office-hours), ceo, design, eng or devex — over a plan, using the passes that review actually runs. Returns findings, the tasks they imply, what is out of scope, what already exists, and its open decisions already shaped as requestUserDecision questions. The workspace agent asks those in the chat, appends the answers to the Decisions node wired into this review, and reruns it to apply them.

// Read a GitHub repository at a branch and map it against a request or a plan: which conventions apply, what already exists for each part of it (with paths), what does not exist yet, and where it touches shared code — plus facts written by code: the branch's commits beyond its base, the pull requests open into it, and the checks the repository can run. Reads the convention files and the files a model picks; a small repository is read whole. Wire its map into every Plan review so their findings are grounded in real code.

// Create the plan's working branch in a GitHub repository, off a base branch, and hand every downstream node the repository to work in. Lanes branch off it and open their pull requests back into it; the Codebase map reads it. Re-running reuses an existing branch and never moves it. Needs a GitHub connection that can write to the repository.

// Bring a branch up to date by merging another branch into it on GitHub — one merge commit, like GitHub's "Update branch" button. Never rebases or force-pushes. A conflict is reported as a result, with nothing written. Use it on a Lane's branch after another Lane was merged into the working branch, or on the working branch when its base moved. Refuses the default branch and protected branches. Do not run it while a Lane is working on the branch.

// Delete the branches earlier plans left behind in a GitHub repository — never work that exists nowhere else. Run it with no branches to look: every branch under a prefix (vibe/ by default), what deleting it would lose, and a ready question card offering only the safe ones (merged, or kept on a closed pull request). Run it again with the picked branches to delete them; each is re-checked first. Never touches the default branch, protected branches, the working branch or anything kept.

// Compare two branches of a GitHub repository: commits ahead and behind, the files changed, and the pull requests open from the branch or into it. No model — read straight from GitHub, so it is cheap to run again after a merge. Wire `repo` from "Working branch".repo to compare the working branch with its base. Reads only.

// Merge a Lane's pull request into the plan's working branch — and only there: the default branch, protected branches and any pull request into another branch are refused, so what ships to the base is always merged by a person. Lands exactly the commit that was checked (wire PR status's `head_sha`), and only when nothing blocks it — the same blockers PR status shows. Marks a draft ready first. Squash by default. Run it only after the user said to merge.

// Everything to check before merging a pull request, read from GitHub with no model: open or merged, draft, whether it still merges cleanly or fell behind its base, CI on its head commit, the review decision, and the review comments still open. Returns `blockers` — the same list Merge PR refuses on — and turns open comments from people with write access into fixes plus a ready question card, the same shape as Code review's. Wire a Lane's `pr_url`. Reads only.

// Review a pull request or a branch the way gstack's pre-landing /review does: read the change from GitHub, check it against what it was asked to do, and run the critical and informational passes over the diff. Returns a verdict, findings with file and line, and the question that asks which findings to fix, ready for requestUserDecision. Reads only; posts nothing to GitHub.

// Open a pull request between two branches of a GitHub repository — or, when one is already open, update that one (title, its own part of the description, draft or ready). Never opens a second. Built for the pull request that ships the working branch to its base once the Lanes are merged: wire "Working branch".repo and "Working branch".base_branch. It never merges and never pushes; merging into the base stays a person's decision on GitHub.

// Run a coding agent in a lane's folder. Wire the lane's Worktree folder, an approved brief and a Decisions block into it; the agent works on the lane's branch, commits as it goes, pushes, and runs your checks — or stops and asks when the brief does not answer something. It never clones and never opens a pull request: a fix round is another run of this same node on the same folder (each result carries the lane's round count), and the Pull request node opens the PR for the commit these checks ran on.

// A lane's folder: its own git worktree of a GitHub repository, on its own branch, kept in the workspace between runs. Wire a Repository (and the Working branch it should start from) into it; it creates the folder the first time and brings it up to date with GitHub every time after. Every Code agent of the lane works in this folder. Set Mode to archive after the lane's pull request merges to remove the folder — it is kept if anything in it would be lost.

// Changes an existing image from a text instruction and keeps the rest: rewrite or translate the text shown in it (signs, labels, posters), add, remove or swap objects, change colors, materials, lighting or style, or restyle a photo into a rendering. Up to 10 reference images. Use it to change an image the user already has; Image Creation makes a new image from text alone. Aspect ratio can match the first input. Megapixel applies on local backends only (xAI returns a fixed size).

// Generates an image from a text prompt. Supports configurable aspect ratio and megapixel resolution. Megapixel is honored on local backends; cloud backends (xAI) return their own fixed size.

// Transform a text using a custom prompt via an LLM, or answer a question about an image (image Q&A) with a vision model: e.g. read the room labels on a floor plan or describe a photo. Input text and/or an image plus instructions; output the elaborated text, optionally parsed as JSON.

// Detects scene and shot boundaries in video. Supports detection of hard cuts and gradual transitions. Returns timecodes, durations, and keyframe timestamps.

// Deterministic final stage of the Human Codex interview pipeline (no LLM). Parses the three pass outputs (Pass 1 per_item array, Pass 3 analysis object, Pass 4 presentation object), tolerating code fences and surrounding prose, assembles the single schema v2.0 profile JSON {schema_version, per_item, analysis, presentation}, renders a readable second-person Markdown report from the presentation layer, and reports validation notes (OK, or WARNING/ERROR lines naming the pass to re-run). Fails when analysis or presentation is not valid JSON.

// Generate a vector SVG illustration or icon from a text prompt, or vectorize a connected raster image.

// Reads the processed text content of one or more Drive files of any type: extracted text for documents (PDF, DOCX, TXT, MD) and speaker-labelled transcripts for audio and video. Multiple items are merged into a single output.

// Search the public web (via Brave Search) and return a ranked list of result URLs (no snippets — deliberate, to avoid SERP-snippet hallucination). The output is a URL list; reading the content behind those URLs is a separate concern handled downstream. Pairs with: `Fetch URL as Markdown`.

// Summarizes large text content using an LLM. Automatically splits long documents into chunks and summarizes them hierarchically to produce a final summary.

// Prepares a social media post payload and renders a platform-native HTML preview (Facebook, Instagram, X/Twitter, LinkedIn). Does not publish — the payload feeds a future publisher node.

// Compose a view of a 3D model directly on the node card — orbit, zoom, field of view, environment and material settings — then capture it as an image at a configurable aspect ratio and resolution. The captured picture is exactly what the preview shows.

// Retopologizes a 3D mesh: voxel remesh, QuadriFlow quad remesh, Geometry Nodes (bundled templates or a custom .blend), or a Remesh+Decimate pipeline.

// Re-textures an existing 3D mesh (GLB) from a reference image, producing higher-fidelity PBR textures (up to 4K). Runs the TRELLIS.2 texturing pass on the input mesh.

// Prepares a 3D model for printing: cleanup, watertight repair, gap sealing, optional remesh/hollowing/decimation. Outputs a printable STL (mm), a preview and a validation report.

// Analyzes a 3D model for printability without modifying it: watertightness, self-intersections, thin walls, overhangs, stability and size metrics. Outputs a scored report, a pass/fail verdict and a preview with problem areas highlighted.

// Preview any node's output. Connect an output to the value input and run: the node shows the value inside itself (expandable to a full-content dialog) and echoes it unchanged to its own value output so you can keep chaining. Accepts any type; non-text values are rendered as formatted JSON.

// Patch (merge) the properties of an existing ontology object or link and return its id.

// Search the organization ontology (knowledge graph) for matching objects plus a match count. Supports entity mode (search by NAME), schema mode (search by RELATIONSHIP/THEME via matching types), and hybrid.

// Bridge documents onto the knowledge graph: given document ids (e.g. semantic chunk hits), return the ontology objects appearing in them, ranked by appearance frequency and connectivity, optionally with the links among them. Wire from KB Semantic Search's documentIds output.

// Fetches the full 360 profile of one ontology entity - its links grouped by type WITH counts (e.g. 'employed_by (incoming): 18'), plus appearance counts - and emits a synthesizer-ready text summary. Wire objectId from Merge Ranked Lists' topId so the top fused entity's relationship profile reaches the answer. This is the node that answers COUNT and relationship questions from the graph.

// Soft-delete (recoverable server-side) an ontology object or link. Returns its id and the delete timestamp.

// Create (or idempotently upsert by identity key) an object in the organization ontology and return its id for chaining into Ontology Create Link.

// Link two ontology objects with a typed edge. Returns the link id and whether the server refused to downgrade an existing higher-confidence link.

// Count ontology objects, grouped by object type. Returns EXACT totals over everything the caller may see — a real census, not a sample or a ranked page. Leave every input empty for a whole-graph breakdown, or set a type for a single count.

// Call an Odoo 19 model method (search_read, read, search, search_count, create, write, unlink, or a custom method) via the Odoo JSON-2 API. Uses the Odoo connection from account settings, or ODOO_URL / ODOO_API_KEY (and optional ODOO_DATABASE) as workspace secrets.

// Fuse two ranked lists of records into one with Reciprocal Rank Fusion (RRF): items surfacing in both lists rank highest. Generic and pure (no network) — wire e.g. Ontology Search's results into listA and Ontology From Documents' entities into listB.

// List all Artifact ids on a Drive item (a Drive item can have many artifacts). Feed each id into Get Artifact to read its content.

// Semantic (vector) search over the knowledge base's document chunks. Returns the ranked chunks, synthesizer-ready chunk texts, and the deduped document ids. Wire chunkTexts into Knowledge Synthesizer's context and documentIds into Ontology From Documents.

// Read an existing Artifact's content and metadata from Drive by its id.

// Fetch a batch of public URLs (1-50) and return per-URL Markdown ready for LLM consumption. Scrapes HTML and converts to Markdown via crawl4ai + Playwright + Chromium. Wire directly from `Web Search` — the urls input accepts the ranked URL array as-is. Returns parallel arrays (markdown, title, error) plus success_count and failed_count. On success each markdown item is prefixed with a Source/title header. Failure is encoded by empty markdown. Pairs with: `Web Search`.

// Reads a video file from Drive and outputs it as a Video file.

// Reads an audio file from Drive and outputs it as an Audio file.

// Reads a 3D file from Drive (GLB, glTF, OBJ, STL, FBX, PLY, USDZ or .blend) and outputs it as a File for 3D nodes like Retopology.

// Generate a knowledge-base-grounded Artifact (document) from a Drive folder using a generation template, then wait for generation to finish and output the content.

// Selects a workspace to reference. Outputs the workspace ID for use with Workspace Break nodes.

// Decomposes a referenced workspace into selectable node inputs and outputs. Configure via the wizard to select which inputs to forward and which outputs to expose.

// Upscales, denoises, or deblurs a video. Upscale uses Topaz Starlight Precise 2.5 (latent diffusion) by default; denoise/deblur use Theia. Supports up to 4x upscaling.

// Normalizes a video to a target resolution, frame rate, and codec. Resize modes include crop (fill frame) and pad (letterbox).

// Detects shot boundaries in video using neural network analysis. Fast and accurate shot detection for professional video editing workflows.

// Generates a video from a text prompt using the LTX 2.3 22B diffusion transformer. Text-to-video (t2v) only — no input image required.

// Regenerates a [start, end] time window of a video from a text prompt, preserving everything outside the window. Audio in the window is regenerated in sync (LTX 2.5).

// Makes the character from an image perform the motion of a reference video (LTX 2.5 motion cloning). Best results when the character's pose and framing match the reference's first frame.

// Matches the color grading of a video to a reference image. Extracts the color profile from the reference and applies it to the video. Strength parameter controls transfer intensity.

// Synchronizes lip movements in a video to match a provided audio track. Lip Expression controls how pronounced the mouth motion is (LatentSync guidance scale). Handles audio/video length mismatches with loop modes and configurable silent padding. Cloud/hybrid: fal-ai/sync-lipsync/v3 (seed, silent_padding, lip expression and inference steps silently ignored). Local: LatentSync 1.6.

// Generates intermediate frames between existing frames. Output mode controls timing: 'smooth' increases frame rate at the same duration; 'slowmo' keeps the original frame rate and stretches the duration.

// Animates a first-frame image into a video guided by a text prompt. Optionally accepts an end frame, an audio track, and a motion reference video (support depends on the active video backend).

// Re-dubs a talking video: generates new speech from the prompt in the source speaker's voice, with lips re-rendered to match (LTX 2.5). Duration follows the source video.

// Generates a video by animating a portrait image driven by an audio clip. Supports configurable output resolution and reproducible seeds. Cloud/hybrid: VEED Fabric 1.0 (480p/720p, audio-driven duration). Local: Sonic.

// Joins multiple videos into a single video. Normalizes all inputs to a common resolution, framerate, and codec. Optionally connect a Make Array to the Video Order port to control concatenation order.

// Overlays a video onto another video with positioning, scaling, optional cropping, and optional green-screen removal.

// Overlays a static image onto a video at a specified position and size.

// Merges two text inputs into a single output. Supports configurable separators, templates, and formatting options.

// Converts text to speech with support for 23 languages and optional voice cloning. Produces natural, expressive speech from text input.

// Converts speech from one voice to another. Provide a source audio clip and a target voice reference to produce the same speech in the target voice.

// Runs a RAG agent that retrieves and analyzes data from Drive. Select a folder or file as context, provide a prompt, and the agent will search the knowledge base to answer your question.

// A constant text value. Provides a multi-line editor that outputs the text unchanged.

// A constant string value. Outputs a single-line string unchanged.

// A constant numeric value. Outputs a number unchanged.

// A constant JSON object. Provides a JSON editor that outputs the object unchanged.

// Selects a folder from Drive. Outputs the folder reference for use by downstream nodes.

// Selects a file from Drive. Outputs the file reference for use by downstream nodes.

// A constant boolean value. Outputs true or false to downstream nodes.

// Publishes content or files to a public URL. Supports HTML, plain text, and file downloads. Optionally protects with a PIN. Re-running the node refreshes the content without changing the link.

// Generates a music track from a style description and lyrics. Supports configurable BPM, musical key, time signature, duration, and multiple languages.

// [Legacy — use Music Creation instead.] Generates a music track from a style description and lyrics. Supports configurable BPM, musical key, time signature, and duration. Outputs an MP3 audio file.

// Generates a 3D model (GLB) from a single image. Creates textured mesh with configurable polygon count and texture resolution.

// [Legacy — use 3D Model Creation instead.] Generates a 3D model (GLB) from a single image. Creates textured mesh with configurable polygon count and texture resolution.

// A composite node that encapsulates a workspace as a reusable building block. Configure inputs and outputs via the wizard.

// Updates an existing Lark task. Can modify title, description, due/start dates, and mark tasks as complete. Only provided fields are updated.

// Fetches a single Lark tasklist (board) by its ID. Returns the tasklist name, owner, and members. Re-execute to refresh.

// Fetches a single Lark task by its ID. Returns the task summary, status, due date, and members. Re-execute to refresh.

// Fetches details of a single Lark user by their ID. Returns name, email, avatar, and department. Use to enrich task data with member information.

// Lists tasks from a Lark tasklist (board). Supports filtering by completion status and pagination. Connect a Lark List Tasklists node to discover available boards.

// Lists all tasklists (boards) accessible in Lark Suite. Returns names, owners, and member counts. Connect the tasklist ID output to a Lark List Tasks node to retrieve tasks.

// Lists organization members from Lark Suite. Use to discover members for task assignment. Supports filtering by department and pagination.

// Creates a new task in Lark Suite. Supports title, description, due/start dates, member assignment, and tasklist placement.

// Decomposes a JSON object or array into individual output ports. Configure via the wizard to select which properties or items to expose.

// Renders infographic syntax into a PNG or SVG image. Accepts the infographic markup format and produces a rendered output. Use to render manually written or LLM-generated infographic definitions.

// Generates a professional infographic from text content. Uses an LLM to analyze the content and select the best visualization layout. Outputs a PNG or SVG image. Supports 237 templates across charts, lists, comparisons, hierarchies, sequences, and relations.

// Detects objects in images and video. Returns bounding boxes, class labels, and confidence scores across 80 object categories.

// Analyzes images using computer vision. Generates detailed captions, text extraction (OCR), and object detection with bounding boxes.

// Upscales an image to higher resolution. Supports configurable scale factor.

// Generates images where readable text and layout matter — posters, covers, multi-panel illustrations, infographics. Handles English and Chinese. Specialized alternative to Image Creation.

// Removes the background from an image. Outputs a transparent PNG.

// Detects and recognizes text in images and video. Returns text regions, recognized text, and confidence scores. Supports multiple languages.

// Detects human body poses in images and video. Identifies body landmarks, shot types, and camera angles. Supports multi-person detection with configurable thresholds.

// Makes HTTP requests to external APIs. Supports various methods, headers, authentication, and response parsing. Use to integrate external services and fetch data.

// Fetches a document chunk by its ID. Returns the chunk text and source document reference for use with Knowledge Synthesizer nodes.

// A programmable node with custom Python code. Use when no existing template fits your needs. The AI assistant will generate appropriate code, inputs, and outputs based on your instructions.

// Generates test files of various types (image, audio, video) for testing the file handling pipeline.

// Generates a video from a starting image using the WAN 2.2 I2V 14B model via a native GPU service. Optionally guided by a text prompt. Outputs an MP4 video file.

// Creates videos from images. Supports two modes: (1) Image to Video — generates a video from a starting image guided by a text prompt, (2) Audio-Driven Animation — animates a starting image driven by an audio track. Outputs a video file.

// Accepts file inputs, processes them, and produces file outputs. Tests the full file pipeline.

// Upscale a video with Real-ESRGAN accelerated by TensorRT. Pick a variant (x2, x4, anime 6B, 4x-Ultrasharp). First run per variant builds an engine (~5–10 min); subsequent runs are instant.