@xano/cli 1.0.6-beta.2 → 1.0.6-beta.20

package/dist/commands/workspace/pull/index.d.ts

@@ -14,10 +14,4 @@ export default class Pull extends BaseCommand {
         verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
-    /**
-     * Sanitize a document name for use as a filename.
-     * Strips quotes, replaces spaces with underscores, and removes
-     * characters that are unsafe in filenames.
-     */
-    private sanitizeFilename;
 }

package/dist/commands/workspace/pull/index.js

@@ -3,7 +3,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import snakeCase from 'lodash.snakecase';
 import BaseCommand from '../../../base-command.js';
-import { buildApiGroupFolderResolver, channelPathSegments, parseDocument, } from '../../../utils/document-parser.js';
+import { buildApiGroupFolderResolver, buildChannelServerResolver, parseDocument, resolveDocumentPath, } from '../../../utils/document-parser.js';
 import { fetchKnowledge, writeKnowledge } from '../../../utils/knowledge-sync.js';
 export default class Pull extends BaseCommand {
     static description = 'Pull a workspace multidoc from the Xano Metadata API and split into individual files';
@@ -134,116 +134,19 @@ Pulled 58 documents
         // Resolve api_group names to unique folder names, disambiguating collisions
         // where different names produce the same snakeCase (e.g., "Authentication" vs "authentication")
         const getApiGroupFolder = buildApiGroupFolderResolver(documents, snakeCase);
+        // Resolve a realtime v2 channel path -> owning realtime_server name, so
+        // messages can nest under their channel's server (see resolver docs).
+        const getChannelServer = buildChannelServerResolver(documents);
         // Track filenames per type to handle duplicates
         const filenameCounters = new Map();
         let writtenCount = 0;
         for (const doc of documents) {
-            let typeDir;
-            let baseName;
-            if (doc.type === 'workspace') {
-                // workspace → workspace/{name}.xs
-                typeDir = path.join(outputDir, 'workspace');
-                baseName = this.sanitizeFilename(doc.name);
-            }
-            else if (doc.type === 'workspace_trigger') {
-                // workspace_trigger → workspace/trigger/{name}.xs
-                typeDir = path.join(outputDir, 'workspace', 'trigger');
-                baseName = this.sanitizeFilename(doc.name);
-            }
-            else if (doc.type === 'error_trigger') {
-                // error_trigger → workspace/trigger/{name}.xs (singleton, colocated with workspace triggers)
-                typeDir = path.join(outputDir, 'workspace', 'trigger');
-                baseName = this.sanitizeFilename(doc.name);
-            }
-            else if (doc.type === 'agent') {
-                // agent → ai/agent/{name}.xs
-                typeDir = path.join(outputDir, 'ai', 'agent');
-                baseName = this.sanitizeFilename(doc.name);
-            }
-            else if (doc.type === 'mcp_server') {
-                // mcp_server → ai/mcp_server/{name}.xs
-                typeDir = path.join(outputDir, 'ai', 'mcp_server');
-                baseName = this.sanitizeFilename(doc.name);
-            }
-            else if (doc.type === 'tool') {
-                // tool → ai/tool/{name}.xs
-                typeDir = path.join(outputDir, 'ai', 'tool');
-                baseName = this.sanitizeFilename(doc.name);
-            }
-            else if (doc.type === 'agent_trigger') {
-                // agent_trigger → ai/agent/trigger/{name}.xs
-                typeDir = path.join(outputDir, 'ai', 'agent', 'trigger');
-                baseName = this.sanitizeFilename(doc.name);
-            }
-            else if (doc.type === 'mcp_server_trigger') {
-                // mcp_server_trigger → ai/mcp_server/trigger/{name}.xs
-                typeDir = path.join(outputDir, 'ai', 'mcp_server', 'trigger');
-                baseName = this.sanitizeFilename(doc.name);
-            }
-            else if (doc.type === 'table_trigger') {
-                // table_trigger → table/trigger/{name}.xs
-                typeDir = path.join(outputDir, 'table', 'trigger');
-                baseName = this.sanitizeFilename(doc.name);
-            }
-            else if (doc.type === 'realtime_channel') {
-                // realtime_channel → realtime/channel/{name}.xs
-                typeDir = path.join(outputDir, 'realtime', 'channel');
-                baseName = this.sanitizeFilename(doc.name);
-            }
-            else if (doc.type === 'realtime_trigger') {
-                // realtime_trigger → realtime/trigger/{name}.xs
-                typeDir = path.join(outputDir, 'realtime', 'trigger');
-                baseName = this.sanitizeFilename(doc.name);
-            }
-            else if (doc.type === 'channel') {
-                // Realtime v2. The channel owns a directory mirroring its path and its
-                // messages live inside it, so ownership is visible in the tree.
-                //   channel "rooms/{room_id}" → channel/rooms/[room_id]/_channel.xs
-                //
-                // The document uses a FIXED "_channel.xs" leaf: naming it after the
-                // last segment yields "[room_id].xs", which names the parameter rather
-                // than the channel. A fixed leaf also sorts first, making "the channel
-                // vs its messages" obvious.
-                typeDir = path.join(outputDir, 'channel', ...channelPathSegments(doc.name, snakeCase));
-                baseName = '_channel';
-            }
-            else if (doc.type === 'message' && doc.channel) {
-                // Realtime v2 message → channel/{channel_path}/{message_name}.xs
-                // Nesting matters beyond tidiness: message names are unique only WITHIN
-                // a channel, so a flat message/ directory would collide when two
-                // channels both define e.g. "say".
-                typeDir = path.join(outputDir, 'channel', ...channelPathSegments(doc.channel, snakeCase));
-                baseName = this.sanitizeFilename(doc.name);
-            }
-            else if (doc.type === 'api_group') {
-                // api_group "test" → api/{resolved_folder}/{name}.xs
-                const groupFolder = getApiGroupFolder(doc.name);
-                typeDir = path.join(outputDir, 'api', groupFolder);
-                baseName = this.sanitizeFilename(doc.name);
-            }
-            else if (doc.type === 'query' && doc.apiGroup) {
-                // query in group "test" → api/{resolved_folder}/{query_name}.xs
-                const groupFolder = getApiGroupFolder(doc.apiGroup);
-                const nameParts = doc.name.split('/');
-                const leafName = nameParts.pop();
-                const folderParts = nameParts.map((part) => snakeCase(part));
-                typeDir = path.join(outputDir, 'api', groupFolder, ...folderParts);
-                baseName = this.sanitizeFilename(leafName);
-                if (doc.verb) {
-                    baseName = `${baseName}_${doc.verb}`;
-                }
-            }
-            else {
-                // Default: split folder path from name
-                const nameParts = doc.name.split('/');
-                const leafName = nameParts.pop();
-                const folderParts = nameParts.map((part) => snakeCase(part));
-                typeDir = path.join(outputDir, doc.type, ...folderParts);
-                baseName = this.sanitizeFilename(leafName);
-                if (doc.verb) {
-                    baseName = `${baseName}_${doc.verb}`;
-                }
-            }
+            const { baseName, typeDir } = resolveDocumentPath(doc, outputDir, {
+                getApiGroupFolder,
+                getChannelServer,
+                join: path.join,
+                snakeCase,
+            });
             fs.mkdirSync(typeDir, { recursive: true });
             // Track duplicates per directory
             const dirKey = path.relative(outputDir, typeDir);
@@ -272,12 +175,4 @@ Pulled 58 documents
             parts.push(`${knowledgeCount} knowledge file${knowledgeCount === 1 ? '' : 's'}`);
         this.log(`Pulled ${parts.join(' + ')} to ${flags.directory}`);
     }
-    /**
-     * Sanitize a document name for use as a filename.
-     * Strips quotes, replaces spaces with underscores, and removes
-     * characters that are unsafe in filenames.
-     */
-    sanitizeFilename(name) {
-        return snakeCase(name.replaceAll('"', ''));
-    }
 }

package/dist/utils/concurrency.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Run `worker` over `items` with at most `limit` in flight at once.
+ *
+ * Results come back in **input order**, not completion order. That matters for
+ * test runners: a concurrent run must still produce output a human can diff
+ * against a sequential one, and a JSON results array whose order does not shift
+ * between runs.
+ *
+ * `limit` is clamped to at least 1, so a limit of 1 is exactly sequential
+ * execution and callers do not need a separate code path for it.
+ *
+ * The worker is expected to capture its own failures — one rejected worker
+ * rejects the whole call. Callers that want per-item error reporting (as the
+ * test runners do) should resolve a failure result instead of throwing.
+ */
+export declare function mapWithConcurrency<T, R>(items: T[], limit: number, worker: (item: T, index: number) => Promise<R>): Promise<R[]>;
+/**
+ * Emit results in input order as soon as each becomes available, without
+ * waiting for the whole batch.
+ *
+ * Progress lines are the reason this exists: with concurrency the third test may
+ * finish before the first, but printing them out of order makes the output hard
+ * to follow and non-deterministic between runs. This buffers out-of-order
+ * completions and flushes the moment the next expected index arrives, so the
+ * user sees an ordered stream that still starts before the run ends.
+ */
+export declare function createOrderedEmitter<R>(onReady: (result: R, index: number) => void): {
+    settle(index: number, result: R): void;
+};

package/dist/utils/concurrency.js

@@ -0,0 +1,54 @@
+/**
+ * Run `worker` over `items` with at most `limit` in flight at once.
+ *
+ * Results come back in **input order**, not completion order. That matters for
+ * test runners: a concurrent run must still produce output a human can diff
+ * against a sequential one, and a JSON results array whose order does not shift
+ * between runs.
+ *
+ * `limit` is clamped to at least 1, so a limit of 1 is exactly sequential
+ * execution and callers do not need a separate code path for it.
+ *
+ * The worker is expected to capture its own failures — one rejected worker
+ * rejects the whole call. Callers that want per-item error reporting (as the
+ * test runners do) should resolve a failure result instead of throwing.
+ */
+export async function mapWithConcurrency(items, limit, worker) {
+    const effectiveLimit = Math.max(1, Math.floor(limit));
+    const results = Array.from({ length: items.length });
+    let cursor = 0;
+    const runners = Array.from({ length: Math.min(effectiveLimit, items.length) }, async () => {
+        while (cursor < items.length) {
+            const index = cursor;
+            cursor++;
+            // eslint-disable-next-line no-await-in-loop
+            results[index] = await worker(items[index], index);
+        }
+    });
+    await Promise.all(runners);
+    return results;
+}
+/**
+ * Emit results in input order as soon as each becomes available, without
+ * waiting for the whole batch.
+ *
+ * Progress lines are the reason this exists: with concurrency the third test may
+ * finish before the first, but printing them out of order makes the output hard
+ * to follow and non-deterministic between runs. This buffers out-of-order
+ * completions and flushes the moment the next expected index arrives, so the
+ * user sees an ordered stream that still starts before the run ends.
+ */
+export function createOrderedEmitter(onReady) {
+    const pending = new Map();
+    let next = 0;
+    return {
+        settle(index, result) {
+            pending.set(index, result);
+            while (pending.has(next)) {
+                onReady(pending.get(next), next);
+                pending.delete(next);
+                next++;
+            }
+        },
+    };
+}

package/dist/utils/document-parser.d.ts

@@ -6,6 +6,8 @@ export interface ParsedDocument {
     content: string;
     guid?: string;
     name: string;
+    /** Owning realtime_server name for realtime v2 `channel` documents. */
+    server?: string;
     type: string;
     verb?: string;
 }
@@ -38,6 +40,63 @@ export declare function parseDocument(content: string): null | ParsedDocument;
  * Mirrors Vfs::channelSegment() on the server.
  */
 export declare function channelPathSegments(name: string, snakeCaseFn: (s: string) => string): string[];
+/**
+ * Build a map of realtime v2 channel path -> owning realtime_server name.
+ *
+ * This is the cross-document lookup the on-disk nesting needs: a `message`
+ * document names its channel (`channel = "..."`), while a `channel` document
+ * names its server (`realtime_server = "..."`). To place a message under
+ * `realtime/server/<server>/channel/<path>/...` we resolve the message's channel
+ * to that channel's server — which the channel document carries. (Messages now
+ * also carry `realtime_server` directly, but resolving via the channel keeps a
+ * single source of truth for the channel→server mapping.)
+ *
+ * Because every pull path parses the WHOLE multidoc into memory before writing,
+ * we can build this map from the `channel` docs in the same batch (a two-pass
+ * resolve), keyed by the channel's own name (its path). A channel with no
+ * `realtime_server` (e.g. a pre-server export) simply isn't in the map, and
+ * callers fall back accordingly.
+ */
+export declare function buildChannelServerResolver(documents: ParsedDocument[]): (channelName: string) => string | undefined;
+/**
+ * Sanitize a document name for use as a single on-disk filename segment.
+ * Strips quotes and snake_cases the rest. Mirrors the per-command
+ * `sanitizeFilename` the pull commands used to each define privately.
+ */
+export declare function sanitizeDocumentName(name: string, snakeCaseFn: (s: string) => string): string;
+/**
+ * The directory + base filename (no extension, no duplicate suffix) a document
+ * is written to on disk. `resolveDocumentPath` returns this; callers append the
+ * `.xs` extension and any `_N` duplicate suffix.
+ */
+export interface DocumentPlacement {
+    baseName: string;
+    typeDir: string;
+}
+/**
+ * Resolve where a parsed document lands on disk — the SINGLE source of truth for
+ * the pull layout, shared by every pull command (workspace, tenant, release,
+ * sandbox, ephemeral). Previously each command inlined a ~130-line copy of this
+ * decision; the copies drifted (the realtime v2 realtime_server/channel/message
+ * branches existed only in workspace/tenant), so an ephemeral pull dumped v2
+ * objects into flat top-level channel/, message/ and realtime_server/ folders —
+ * detaching messages from their channels and risking name collisions (message
+ * names are unique only WITHIN a channel).
+ *
+ * @param doc - the parsed document
+ * @param outputDir - the resolved pull output root
+ * @param deps - injected dependencies
+ * @param deps.getApiGroupFolder - resolves an api_group name to its unique folder
+ * @param deps.getChannelServer - resolves a v2 channel path to its owning realtime_server
+ * @param deps.join - the path.join implementation (injectable for testing)
+ * @param deps.snakeCase - the snakeCase implementation the caller uses
+ */
+export declare function resolveDocumentPath(doc: ParsedDocument, outputDir: string, deps: {
+    getApiGroupFolder: (groupName: string) => string;
+    getChannelServer: (channelName: string) => string | undefined;
+    join: (...parts: string[]) => string;
+    snakeCase: (s: string) => string;
+}): DocumentPlacement;
 /**
  * Build a unique key for a document based on its type, name, verb, and api_group.
  * Used to match server GUID map entries back to local files.
@@ -63,3 +122,34 @@ export declare function findFilesWithGuid(entries: Array<{
     content: string;
     filePath: string;
 }>, guid: string): string[];
+/**
+ * Split a multi-document XanoScript blob (documents joined by `\n---\n`) into
+ * parsed documents, skipping empties and any fragment that fails to parse.
+ *
+ * This is the same split the pull commands apply to the server's multidoc
+ * response. A hand-authored bundle is one file of many `---`-separated
+ * documents; this turns it back into the per-document units every downstream
+ * step (placement, GUID writeback, partial-diff matching) assumes.
+ */
+export declare function splitMultidoc(blob: string): ParsedDocument[];
+/** A document's resolved on-disk location relative to the output root, plus its content. */
+export interface PlacedDocument {
+    content: string;
+    /** POSIX-style path relative to the output root, e.g. "api/pdf/documents_GET.xs". */
+    relPath: string;
+}
+/**
+ * Compute where each document lands on disk — a PURE function (no filesystem)
+ * mirroring the split-and-place loop the pull commands run. It resolves each
+ * document via `resolveDocumentPath`, appends `.xs`, and disambiguates
+ * collisions within a directory with a `_N` suffix (the second file named
+ * `say.xs` in a dir becomes `say_2.xs`), exactly as the pull writer does.
+ *
+ * Kept filesystem-free so it can be unit-tested and reused by both the pull
+ * commands and `flatten` without duplicating the placement rules.
+ */
+export declare function placeDocuments(documents: ParsedDocument[], deps: {
+    join: (...parts: string[]) => string;
+    relative: (from: string, to: string) => string;
+    snakeCase: (s: string) => string;
+}): PlacedDocument[];

package/dist/utils/document-parser.js

@@ -53,6 +53,17 @@ export function parseDocument(content) {
     if (channelMatch) {
         channel = channelMatch[1];
     }
+    // Extract realtime_server if present (e.g., realtime_server = "chat").
+    // Realtime v2 channels/messages reference their owning realtime_server by NAME
+    // via a top-level `realtime_server = "..."`, which is what nests them under it
+    // on disk (mirrors how a message names its channel via `channel = "..."`).
+    // The keyword is `realtime_server` (renamed from a bare `server` to match the
+    // api_group/mcp_server convention — reference the container by its full type).
+    let server;
+    const serverMatch = content.match(/^\s*realtime_server\s*=\s*"([^"]*)"/m);
+    if (serverMatch) {
+        server = serverMatch[1];
+    }
     // Extract canonical if present (e.g., canonical = "abc123")
     let canonical;
     const canonicalMatch = content.match(/canonical\s*=\s*"([^"]*)"/);
@@ -65,7 +76,7 @@ export function parseDocument(content) {
     if (guidMatch) {
         guid = guidMatch[1];
     }
-    return { apiGroup, canonical, channel, content, guid, name, type, verb };
+    return { apiGroup, canonical, channel, content, guid, name, server, type, verb };
 }
 /**
  * Map a realtime v2 channel path onto directory segments.
@@ -96,6 +107,207 @@ export function channelPathSegments(name, snakeCaseFn) {
     const isParam = /^\{.*\}$/;
     return name.split('/').map((segment) => (isParam.test(segment) ? `[${segment.slice(1, -1)}]` : snakeCaseFn(segment)));
 }
+/**
+ * Build a map of realtime v2 channel path -> owning realtime_server name.
+ *
+ * This is the cross-document lookup the on-disk nesting needs: a `message`
+ * document names its channel (`channel = "..."`), while a `channel` document
+ * names its server (`realtime_server = "..."`). To place a message under
+ * `realtime/server/<server>/channel/<path>/...` we resolve the message's channel
+ * to that channel's server — which the channel document carries. (Messages now
+ * also carry `realtime_server` directly, but resolving via the channel keeps a
+ * single source of truth for the channel→server mapping.)
+ *
+ * Because every pull path parses the WHOLE multidoc into memory before writing,
+ * we can build this map from the `channel` docs in the same batch (a two-pass
+ * resolve), keyed by the channel's own name (its path). A channel with no
+ * `realtime_server` (e.g. a pre-server export) simply isn't in the map, and
+ * callers fall back accordingly.
+ */
+export function buildChannelServerResolver(documents) {
+    const channelToServer = new Map();
+    for (const doc of documents) {
+        if (doc.type === 'channel' && doc.server) {
+            channelToServer.set(doc.name, doc.server);
+        }
+    }
+    return (channelName) => channelToServer.get(channelName);
+}
+/**
+ * Sanitize a document name for use as a single on-disk filename segment.
+ * Strips quotes and snake_cases the rest. Mirrors the per-command
+ * `sanitizeFilename` the pull commands used to each define privately.
+ */
+export function sanitizeDocumentName(name, snakeCaseFn) {
+    return snakeCaseFn(name.replaceAll('"', ''));
+}
+/**
+ * Resolve where a parsed document lands on disk — the SINGLE source of truth for
+ * the pull layout, shared by every pull command (workspace, tenant, release,
+ * sandbox, ephemeral). Previously each command inlined a ~130-line copy of this
+ * decision; the copies drifted (the realtime v2 realtime_server/channel/message
+ * branches existed only in workspace/tenant), so an ephemeral pull dumped v2
+ * objects into flat top-level channel/, message/ and realtime_server/ folders —
+ * detaching messages from their channels and risking name collisions (message
+ * names are unique only WITHIN a channel).
+ *
+ * @param doc - the parsed document
+ * @param outputDir - the resolved pull output root
+ * @param deps - injected dependencies
+ * @param deps.getApiGroupFolder - resolves an api_group name to its unique folder
+ * @param deps.getChannelServer - resolves a v2 channel path to its owning realtime_server
+ * @param deps.join - the path.join implementation (injectable for testing)
+ * @param deps.snakeCase - the snakeCase implementation the caller uses
+ */
+export function resolveDocumentPath(doc, outputDir, deps) {
+    const { getApiGroupFolder, getChannelServer, join, snakeCase } = deps;
+    const sanitize = (name) => sanitizeDocumentName(name, snakeCase);
+    if (doc.type === 'workspace') {
+        // workspace → workspace/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'workspace') };
+    }
+    if (doc.type === 'workspace_trigger' || doc.type === 'error_trigger') {
+        // workspace_trigger / error_trigger → workspace/trigger/{name}.xs
+        // (error_trigger is a singleton, colocated with workspace triggers)
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'workspace', 'trigger') };
+    }
+    if (doc.type === 'agent') {
+        // agent → ai/agent/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'ai', 'agent') };
+    }
+    if (doc.type === 'mcp_server') {
+        // mcp_server → ai/mcp_server/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'ai', 'mcp_server') };
+    }
+    if (doc.type === 'tool') {
+        // tool → ai/tool/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'ai', 'tool') };
+    }
+    if (doc.type === 'agent_trigger') {
+        // agent_trigger → ai/agent/trigger/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'ai', 'agent', 'trigger') };
+    }
+    if (doc.type === 'mcp_server_trigger') {
+        // mcp_server_trigger → ai/mcp_server/trigger/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'ai', 'mcp_server', 'trigger') };
+    }
+    if (doc.type === 'table_trigger') {
+        // table_trigger → table/trigger/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'table', 'trigger') };
+    }
+    if (doc.type === 'realtime_channel') {
+        // Realtime v1: realtime_channel → realtime/channel/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'realtime', 'channel') };
+    }
+    if (doc.type === 'realtime_trigger') {
+        // Realtime v1: realtime_trigger → realtime/trigger/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'realtime', 'trigger') };
+    }
+    if (doc.type === 'realtime_server_trigger') {
+        // Realtime v2. A realtime_server's connect/disconnect trigger. It references its
+        // owning server by name via `realtime_server = "..."`, so it nests under that
+        // server's folder as `<server>/trigger/`, mirroring how the server's own document
+        // and its channels already nest under realtime/server/<server>/ (DEV-7712). Keeping
+        // it there means every realtime document stays under realtime/ instead of landing at
+        // the output root. A server-less doc (a malformed/legacy export) falls back to a flat
+        // realtime/server_trigger/ under realtime/ rather than the repo root.
+        return {
+            baseName: sanitize(doc.name),
+            typeDir: doc.server
+                ? join(outputDir, 'realtime', 'server', sanitize(doc.server), 'trigger')
+                : join(outputDir, 'realtime', 'server_trigger'),
+        };
+    }
+    if (doc.type === 'channel_trigger') {
+        // Realtime v2. A channel's join/leave/deliver trigger. It references BOTH its owning
+        // server (`realtime_server = "..."`) and its channel (`channel = "..."`), so it nests
+        // beside that channel as `<server>/channel/<channel>/trigger/` — the same path the
+        // channel's own document and messages already use (DEV-7712). Falls back gracefully:
+        // channel but no resolvable server → the legacy flat channel/<path>/trigger/ layout;
+        // neither → realtime/channel_trigger/ under realtime/ (never the output root).
+        if (doc.server && doc.channel) {
+            return {
+                baseName: sanitize(doc.name),
+                typeDir: join(outputDir, 'realtime', 'server', sanitize(doc.server), 'channel', snakeCase(doc.channel), 'trigger'),
+            };
+        }
+        if (doc.channel) {
+            return {
+                baseName: sanitize(doc.name),
+                typeDir: join(outputDir, 'channel', ...channelPathSegments(doc.channel, snakeCase), 'trigger'),
+            };
+        }
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'realtime', 'channel_trigger') };
+    }
+    if (doc.type === 'realtime_server') {
+        // Realtime v2. The realtime_server is the top-level container that owns
+        // channels (which own messages). Its own document is named after itself
+        // inside its name directory, mirroring api_group (api/<group>/<group>.xs).
+        //   realtime_server "chat" → realtime/server/chat/chat.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'realtime', 'server', sanitize(doc.name)) };
+    }
+    if (doc.type === 'channel') {
+        // Realtime v2. The channel owns a directory named after itself (the full
+        // channel name, snake_cased into a single flat segment), and its messages
+        // live in a message/ subfolder inside it. It nests under its owning
+        // realtime_server (from `realtime_server = "..."`):
+        //   channel "rooms/{room_id}" (server "chat")
+        //     → realtime/server/chat/channel/rooms_room_id/rooms_room_id.xs
+        //
+        // A channel with no resolvable server (e.g. a pre-server export) falls back
+        // to the legacy flat channel/<path>/_channel.xs layout.
+        if (doc.server) {
+            return {
+                baseName: snakeCase(doc.name),
+                typeDir: join(outputDir, 'realtime', 'server', sanitize(doc.server), 'channel', snakeCase(doc.name)),
+            };
+        }
+        return { baseName: '_channel', typeDir: join(outputDir, 'channel', ...channelPathSegments(doc.name, snakeCase)) };
+    }
+    if (doc.type === 'message' && doc.channel) {
+        // Realtime v2 message → nests in a message/ subfolder under its channel,
+        // under that channel's server (resolved via the two-pass channel→server map).
+        //   message "post" on channel "rooms/{room_id}" (server "chat")
+        //     → realtime/server/chat/channel/rooms_room_id/message/post.xs
+        //
+        // Nesting matters beyond tidiness: message names are unique only WITHIN a
+        // channel, so a flat message/ directory would collide when two channels
+        // both define e.g. "say". A channel whose server can't be resolved falls
+        // back to the legacy flat channel/ layout.
+        const messageServer = getChannelServer(doc.channel);
+        return {
+            baseName: sanitize(doc.name),
+            typeDir: messageServer
+                ? join(outputDir, 'realtime', 'server', sanitize(messageServer), 'channel', snakeCase(doc.channel), 'message')
+                : join(outputDir, 'channel', ...channelPathSegments(doc.channel, snakeCase)),
+        };
+    }
+    if (doc.type === 'api_group') {
+        // api_group "test" → api/{resolved_folder}/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'api', getApiGroupFolder(doc.name)) };
+    }
+    if (doc.type === 'query' && doc.apiGroup) {
+        // query in group "test" → api/{resolved_folder}/{folders}/{query_name}[_verb].xs
+        const groupFolder = getApiGroupFolder(doc.apiGroup);
+        const nameParts = doc.name.split('/');
+        const leafName = nameParts.pop();
+        const folderParts = nameParts.map((part) => snakeCase(part));
+        const baseName = sanitize(leafName);
+        return {
+            baseName: doc.verb ? `${baseName}_${doc.verb}` : baseName,
+            typeDir: join(outputDir, 'api', groupFolder, ...folderParts),
+        };
+    }
+    // Default: split folder path from name
+    const nameParts = doc.name.split('/');
+    const leafName = nameParts.pop();
+    const folderParts = nameParts.map((part) => snakeCase(part));
+    const baseName = sanitize(leafName);
+    return {
+        baseName: doc.verb ? `${baseName}_${doc.verb}` : baseName,
+        typeDir: join(outputDir, doc.type, ...folderParts),
+    };
+}
 /**
  * Build a unique key for a document based on its type, name, verb, and api_group.
  * Used to match server GUID map entries back to local files.
@@ -149,3 +361,63 @@ export function buildApiGroupFolderResolver(documents, snakeCaseFn) {
 export function findFilesWithGuid(entries, guid) {
     return entries.filter((e) => e.content.includes(guid)).map((e) => e.filePath);
 }
+/**
+ * Split a multi-document XanoScript blob (documents joined by `\n---\n`) into
+ * parsed documents, skipping empties and any fragment that fails to parse.
+ *
+ * This is the same split the pull commands apply to the server's multidoc
+ * response. A hand-authored bundle is one file of many `---`-separated
+ * documents; this turns it back into the per-document units every downstream
+ * step (placement, GUID writeback, partial-diff matching) assumes.
+ */
+export function splitMultidoc(blob) {
+    const documents = [];
+    for (const raw of blob.split('\n---\n')) {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            continue;
+        const parsed = parseDocument(trimmed);
+        if (parsed)
+            documents.push(parsed);
+    }
+    return documents;
+}
+/**
+ * Compute where each document lands on disk — a PURE function (no filesystem)
+ * mirroring the split-and-place loop the pull commands run. It resolves each
+ * document via `resolveDocumentPath`, appends `.xs`, and disambiguates
+ * collisions within a directory with a `_N` suffix (the second file named
+ * `say.xs` in a dir becomes `say_2.xs`), exactly as the pull writer does.
+ *
+ * Kept filesystem-free so it can be unit-tested and reused by both the pull
+ * commands and `flatten` without duplicating the placement rules.
+ */
+export function placeDocuments(documents, deps) {
+    const { join, relative, snakeCase } = deps;
+    const getApiGroupFolder = buildApiGroupFolderResolver(documents, snakeCase);
+    const getChannelServer = buildChannelServerResolver(documents);
+    // Per-directory filename counters, so duplicate leaf names get a _N suffix.
+    const filenameCounters = new Map();
+    const placed = [];
+    for (const doc of documents) {
+        const { baseName, typeDir } = resolveDocumentPath(doc, '', {
+            getApiGroupFolder,
+            getChannelServer,
+            join,
+            snakeCase,
+        });
+        const dirKey = typeDir;
+        if (!filenameCounters.has(dirKey))
+            filenameCounters.set(dirKey, new Map());
+        const typeCounters = filenameCounters.get(dirKey);
+        const count = typeCounters.get(baseName) || 0;
+        typeCounters.set(baseName, count + 1);
+        const filename = count === 0 ? `${baseName}.xs` : `${baseName}_${count + 1}.xs`;
+        const abs = join(typeDir, filename);
+        // typeDir was built off an empty root, so `abs` is already root-relative;
+        // normalize any leading separator via relative() for a clean POSIX path.
+        const relPath = relative('', abs);
+        placed.push({ content: doc.content, relPath });
+    }
+    return placed;
+}