@xano/cli 1.0.6-beta.3 → 1.0.6-beta.6

package/dist/commands/workflow_test/list/index.d.ts

@@ -3,9 +3,11 @@ export default class WorkflowTestList extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        page: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        per_page: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-        workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         config: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;

package/dist/commands/workflow_test/list/index.js

@@ -1,5 +1,6 @@
 import { Flags } from '@oclif/core';
 import BaseCommand from '../../../base-command.js';
+import { buildPagingJson, buildPagingParams, formatPagingFooter, normalizeListResponse, pagingFlags } from '../../../utils/paging.js';
 export default class WorkflowTestList extends BaseCommand {
     static description = 'List all workflow tests in a workspace';
     static examples = [
@@ -25,6 +26,7 @@ Workflow tests in workspace 5:
             options: ['summary', 'json'],
             required: false,
         }),
+        ...pagingFlags('envelope', { maxPerPage: 10_000 }),
         workspace: Flags.string({
             char: 'w',
             description: 'Workspace ID (uses profile workspace if not provided)',
@@ -38,7 +40,8 @@ Workflow tests in workspace 5:
         if (!workspaceId) {
             this.error('No workspace ID provided. Use --workspace flag or set one in your profile.');
         }
-        const params = new URLSearchParams({ include_xanoscript: 'false' });
+        const params = new URLSearchParams(buildPagingParams(flags, 'envelope'));
+        params.set('include_xanoscript', 'false');
         if (flags.branch) {
             params.set('branch', flags.branch);
         }
@@ -55,19 +58,10 @@ Workflow tests in workspace 5:
                 const errorText = await response.text();
                 this.error(`API request failed with status ${response.status}: ${response.statusText}\n${errorText}`);
             }
-            const data = await response.json();
-            let tests;
-            if (Array.isArray(data)) {
-                tests = data;
-            }
-            else if (data && typeof data === 'object' && 'items' in data && Array.isArray(data.items)) {
-                tests = data.items;
-            }
-            else {
-                this.error('Unexpected API response format');
-            }
+            const list = normalizeListResponse(await response.json());
+            const tests = list.items;
             if (flags.output === 'json') {
-                this.log(JSON.stringify(tests, null, 2));
+                this.log(JSON.stringify(buildPagingJson(list, { page: flags.page, perPage: flags.per_page, tier: 'envelope' }), null, 2));
             }
             else {
                 if (tests.length === 0) {
@@ -80,6 +74,9 @@ Workflow tests in workspace 5:
                         this.log(`  - ${test.name} (ID: ${test.id})${desc}`);
                     }
                 }
+                const footer = formatPagingFooter(list, { noun: 'workflow test', page: flags.page, tier: 'envelope' });
+                if (footer)
+                    this.log(footer);
             }
         }
         catch (error) {

package/dist/commands/workflow_test/run_all/index.d.ts

@@ -4,6 +4,7 @@ export default class WorkflowTestRunAll extends BaseCommand {
     static examples: string[];
     static flags: {
         branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        concurrency: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         config: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/workflow_test/run_all/index.js

@@ -1,5 +1,7 @@
 import { Flags } from '@oclif/core';
 import BaseCommand from '../../../base-command.js';
+import { createOrderedEmitter, mapWithConcurrency } from '../../../utils/concurrency.js';
+import { collectAllPages, INTERNAL_PAGE_SIZE, normalizeListResponse } from '../../../utils/paging.js';
 export default class WorkflowTestRunAll extends BaseCommand {
     static description = 'Run all workflow tests in a workspace';
     static examples = [
@@ -22,6 +24,11 @@ Results: 2 passed, 1 failed (2.691s total)
             description: 'Filter by branch name',
             required: false,
         }),
+        concurrency: Flags.integer({
+            default: 1,
+            description: 'Run this many tests in parallel. Tests share the workspace database, so raise this only when your tests do not depend on shared state.',
+            required: false,
+        }),
         output: Flags.string({
             char: 'o',
             default: 'summary',
@@ -45,32 +52,35 @@ Results: 2 passed, 1 failed (2.691s total)
         const baseUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/workflow_test`;
         try {
             // Step 1: List all workflow tests
-            const listParams = new URLSearchParams({ include_xanoscript: 'false' });
-            if (flags.branch) {
-                listParams.set('branch', flags.branch);
-            }
-            const listResponse = await this.verboseFetch(`${baseUrl}?${listParams}`, {
-                headers: {
-                    accept: 'application/json',
-                    Authorization: `Bearer ${profile.access_token}`,
+            // Page the list rather than asking for everything at once: 100 per
+            // request is plenty for typical suites and does not make the instance
+            // build one enormous response. Termination is the server's own nextPage,
+            // never "the page came back full".
+            const branchValue = flags.branch;
+            const tests = await collectAllPages(async (page) => {
+                const listParams = new URLSearchParams();
+                listParams.set('page', String(page));
+                listParams.set('per_page', String(INTERNAL_PAGE_SIZE));
+                if (branchValue)
+                    listParams.set('branch', branchValue);
+                listParams.set('include_xanoscript', 'false');
+                const listResponse = await this.verboseFetch(`${baseUrl}?${listParams}`, {
+                    headers: {
+                        accept: 'application/json',
+                        Authorization: `Bearer ${profile.access_token}`,
+                    },
+                    method: 'GET',
+                }, flags.verbose, profile.access_token);
+                if (!listResponse.ok) {
+                    const errorText = await listResponse.text();
+                    this.error(`Failed to list workflow tests: ${listResponse.status}: ${listResponse.statusText}\n${errorText}`);
+                }
+                return normalizeListResponse(await listResponse.json());
+            }, {
+                onTruncate: (collected) => {
+                    this.warn(`Stopped after ${collected} workflow tests — the list did not terminate. Some tests may not have run.`);
                 },
-                method: 'GET',
-            }, flags.verbose, profile.access_token);
-            if (!listResponse.ok) {
-                const errorText = await listResponse.text();
-                this.error(`Failed to list workflow tests: ${listResponse.status}: ${listResponse.statusText}\n${errorText}`);
-            }
-            const data = (await listResponse.json());
-            let tests;
-            if (Array.isArray(data)) {
-                tests = data;
-            }
-            else if (data && typeof data === 'object' && 'items' in data && Array.isArray(data.items)) {
-                tests = data.items;
-            }
-            else {
-                this.error('Unexpected API response format');
-            }
+            });
             if (tests.length === 0) {
                 this.log('No workflow tests found');
                 return;
@@ -81,7 +91,15 @@ Results: 2 passed, 1 failed (2.691s total)
             // Step 2: Run each test
             const results = [];
             let totalTiming = 0;
-            for (const test of tests) {
+            const runOne = async (test) => {
+                // Shadowed accumulators: the body below is the original sequential
+                // logic, but it records output instead of printing it so a concurrent
+                // run can still emit in input order.
+                const results = [];
+                const lines = [];
+                const log = (message) => {
+                    lines.push(message);
+                };
                 const runUrl = `${baseUrl}/${test.id}/run`;
                 try {
                     const runResponse = await this.verboseFetch(runUrl, {
@@ -102,10 +120,10 @@ Results: 2 passed, 1 failed (2.691s total)
                         };
                         results.push(result);
                         if (flags.output === 'summary') {
-                            this.log(`FAIL  ${test.name} (0.000s)`);
-                            this.log(`      Error: API error ${runResponse.status}`);
+                            log(`FAIL  ${test.name} (0.000s)`);
+                            log(`      Error: API error ${runResponse.status}`);
                         }
-                        continue;
+                        return { lines, results };
                     }
                     const runResult = (await runResponse.json());
                     const passed = runResult.status === 'ok';
@@ -120,12 +138,12 @@ Results: 2 passed, 1 failed (2.691s total)
                     if (flags.output === 'summary') {
                         const timing = `(${runResult.timing.toFixed(3)}s)`;
                         if (passed) {
-                            this.log(`PASS  ${test.name} ${timing}`);
+                            log(`PASS  ${test.name} ${timing}`);
                         }
                         else {
-                            this.log(`FAIL  ${test.name} ${timing}`);
+                            log(`FAIL  ${test.name} ${timing}`);
                             if (runResult.message) {
-                                this.log(`      Error: ${runResult.message}`);
+                                log(`      Error: ${runResult.message}`);
                             }
                         }
                     }
@@ -139,16 +157,29 @@ Results: 2 passed, 1 failed (2.691s total)
                         timing: 0,
                     });
                     if (flags.output === 'summary') {
-                        this.log(`FAIL  ${test.name} (0.000s)`);
-                        this.log(`      Error: ${message}`);
+                        log(`FAIL  ${test.name} (0.000s)`);
+                        log(`      Error: ${message}`);
                     }
                 }
-            }
+                return { lines, results };
+            };
+            // Print in input order as each test settles, so concurrent output stays
+            // diffable against a sequential run.
+            const emitter = createOrderedEmitter((settled) => {
+                for (const line of settled.lines)
+                    this.log(line);
+            });
+            const perTest = await mapWithConcurrency(tests, flags.concurrency, async (test, index) => {
+                const settled = await runOne(test);
+                emitter.settle(index, settled);
+                return settled;
+            });
+            results.push(...perTest.flatMap((r) => r.results));
             // Step 3: Summary
             const passed = results.filter((r) => r.status === 'pass').length;
             const failed = results.filter((r) => r.status === 'fail').length;
             if (flags.output === 'json') {
-                this.log(JSON.stringify({ passed, failed, total_timing: totalTiming, results }, null, 2));
+                this.log(JSON.stringify({ failed, passed, results, total_timing: totalTiming }, null, 2));
             }
             else {
                 this.log(`\nResults: ${passed} passed, ${failed} failed (${totalTiming.toFixed(3)}s total)`);

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

@@ -1,5 +1,6 @@
 import { Flags } from '@oclif/core';
 import BaseCommand from '../../../base-command.js';
+import { buildPagingJson, formatPagingFooter, normalizeListResponse } from '../../../utils/paging.js';
 export default class WorkspaceList extends BaseCommand {
     static description = 'List all workspaces from the Xano Metadata API';
     static examples = [
@@ -71,24 +72,14 @@ Available workspaces:
                 const errorText = await response.text();
                 this.error(`API request failed with status ${response.status}: ${response.statusText}\n${errorText}`);
             }
-            const data = (await response.json());
-            // Handle different response formats
-            let workspaces;
-            if (Array.isArray(data)) {
-                workspaces = data;
-            }
-            else if (data && typeof data === 'object' && 'workspaces' in data && Array.isArray(data.workspaces)) {
-                workspaces = data.workspaces;
-            }
-            else {
-                this.error('Unexpected API response format');
-            }
+            const list = normalizeListResponse(await response.json(), ['workspaces']);
+            const workspaces = list.items;
             if (flags.latest) {
                 workspaces.sort((a, b) => b.id - a.id);
             }
             // Output results
             if (flags.output === 'json') {
-                this.log(JSON.stringify(workspaces, null, 2));
+                this.log(JSON.stringify(buildPagingJson(list, { tier: 'none' }), null, 2));
             }
             else {
                 // summary format
@@ -107,6 +98,9 @@ Available workspaces:
                         }
                     }
                 }
+                const footer = formatPagingFooter({ items: workspaces }, { noun: 'workspace', tier: 'none' });
+                if (footer)
+                    this.log(footer);
             }
         }
         catch (error) {

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, buildChannelServerResolver, 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';
@@ -141,141 +141,12 @@ Pulled 58 documents
         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 === '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)
-                // — the server name is a simple segment, so no fixed leaf is needed.
-                //   realtime_server "chat" → realtime/server/chat/chat.xs
-                typeDir = path.join(outputDir, 'realtime', 'server', this.sanitizeFilename(doc.name));
-                baseName = this.sanitizeFilename(doc.name);
-            }
-            else 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 — like every other
-                // object), and its messages live in a message/ subfolder inside it. It
-                // nests under its owning realtime_server (from `server = "..."`):
-                //   channel "rooms/{room_id}" (server "chat")
-                //     → realtime/server/chat/channel/rooms_room_id/rooms_room_id.xs
-                //
-                // The channel name is snake_cased as a whole (rooms/{room_id} →
-                // rooms_room_id), so there is no path nesting and no bracket escaping —
-                // the on-disk name is a display form; the .xs content keeps the real
-                // name. 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) {
-                    typeDir = path.join(outputDir, 'realtime', 'server', this.sanitizeFilename(doc.server), 'channel', snakeCase(doc.name));
-                    baseName = snakeCase(doc.name);
-                }
-                else {
-                    typeDir = path.join(outputDir, 'channel', ...channelPathSegments(doc.name, snakeCase));
-                    baseName = '_channel';
-                }
-            }
-            else if (doc.type === 'message' && doc.channel) {
-                // Realtime v2 message → nests in a message/ subfolder under its channel,
-                // under that channel's server. The message names only its channel; the
-                // server is resolved by looking that channel up in the same multidoc
-                // (two-pass resolve).
-                //   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);
-                typeDir = messageServer
-                    ? path.join(outputDir, 'realtime', 'server', this.sanitizeFilename(messageServer), 'channel', snakeCase(doc.channel), 'message')
-                    : 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);
@@ -304,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

@@ -58,6 +58,45 @@ export declare function channelPathSegments(name: string, snakeCaseFn: (s: strin
  * 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.