glost-processor 0.5.0 → 0.6.0

package/dist/index.d.ts

@@ -22,6 +22,8 @@
 export { GLOSTProcessor } from "./processor.js";
 export type { FrozenProcessor } from "./processor.js";
 export type { Plugin, PluginSpec, Preset, ProcessorOptions, ProcessingResult, ProcessingError, ProcessingWarning, ProcessingStats, BeforeHook, AfterHook, ErrorHook, SkipHook, ProgressHook, ProgressStats, } from "./types.js";
+export { GLOSTStreamProcessor } from "./stream-processor.js";
+export type { FrozenStreamProcessor, StreamOptions, ProcessedChunk, } from "./stream-processor.js";
 import { GLOSTProcessor } from "./processor.js";
 import type { ProcessorOptions } from "./types.js";
 /**

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,YAAY,EACV,MAAM,EACN,UAAU,EACV,MAAM,EACN,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,UAAU,EACV,SAAS,EACT,SAAS,EACT,QAAQ,EACR,YAAY,EACZ,aAAa,GACd,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,KAAK,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,cAAc,CAEhE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,YAAY,EACV,MAAM,EACN,UAAU,EACV,MAAM,EACN,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,UAAU,EACV,SAAS,EACT,SAAS,EACT,QAAQ,EACR,YAAY,EACZ,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAC7D,YAAY,EACV,qBAAqB,EACrB,aAAa,EACb,cAAc,GACf,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,KAAK,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,cAAc,CAEhE"}

package/dist/index.js

@@ -20,6 +20,7 @@
  * ```
  */
 export { GLOSTProcessor } from "./processor.js";
+export { GLOSTStreamProcessor } from "./stream-processor.js";
 import { GLOSTProcessor } from "./processor.js";
 /**
  * Create a new GLOST processor

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAmBhD,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,KAAK,CAAC,OAA0B;IAC9C,OAAO,IAAI,cAAc,CAAC,OAAO,CAAC,CAAC;AACrC,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAkBhD,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAO7D,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,KAAK,CAAC,OAA0B;IAC9C,OAAO,IAAI,cAAc,CAAC,OAAO,CAAC,CAAC;AACrC,CAAC"}

package/dist/stream-processor.d.ts

@@ -0,0 +1,145 @@
+/**
+ * GLOST Stream Processor
+ *
+ * Streaming variant of GLOSTProcessor that yields processed sentence
+ * batches progressively using AsyncGenerator. Keeps the full document
+ * out of memory between chunks.
+ *
+ * Document-level transforms (extensions with streamingSupport !== 'chunk')
+ * run once on the full document before streaming begins. Chunk-compatible
+ * extensions (streamingSupport === 'chunk') then run on each batch.
+ *
+ * @packageDocumentation
+ *
+ * @example
+ * ```typescript
+ * import { GLOSTStreamProcessor } from "glost-processor";
+ *
+ * const processor = new GLOSTStreamProcessor()
+ *   .use(transcription)
+ *   .use(translation);
+ *
+ * for await (const chunk of processor.stream(document)) {
+ *   console.log(chunk.sentences, chunk.isLast);
+ * }
+ * ```
+ *
+ * @since 0.7.0
+ */
+import type { GLOSTRoot, GLOSTSentence } from "glost-core";
+import type { PluginSpec, Preset, ProcessorOptions } from "./types.js";
+/**
+ * Options for stream() method
+ *
+ * @since 0.7.0
+ */
+export interface StreamOptions {
+    /**
+     * Number of sentences per chunk.
+     *
+     * A smaller value reduces latency to first yielded chunk; a larger
+     * value amortises per-chunk overhead. Default: 50.
+     */
+    batchSize?: number;
+}
+/**
+ * A single yielded chunk from the stream
+ *
+ * @since 0.7.0
+ */
+export interface ProcessedChunk {
+    /** Processed sentences in this batch */
+    sentences: GLOSTSentence[];
+    /**
+     * Index of the source paragraph this chunk came from.
+     *
+     * When the document has multiple paragraphs each paragraph is
+     * chunked independently, so multiple consecutive chunks may share
+     * the same paragraphIndex.
+     */
+    paragraphIndex: number;
+    /**
+     * Index of this chunk within its paragraph (0-based).
+     */
+    chunkIndex: number;
+    /** True for the final chunk across the whole document */
+    isLast: boolean;
+}
+/**
+ * Streaming processor for GLOST documents
+ *
+ * Mirrors the `GLOSTProcessor` API (`.use()`, `.freeze()`) but adds a
+ * `.stream()` method that returns an `AsyncGenerator<ProcessedChunk>`.
+ *
+ * @since 0.7.0
+ */
+export declare class GLOSTStreamProcessor {
+    private plugins;
+    private options;
+    private frozen;
+    /**
+     * Create a new stream processor instance
+     *
+     * @param options - Initial processor options
+     */
+    constructor(options?: ProcessorOptions);
+    /**
+     * Add a plugin, preset, or extension to the pipeline
+     *
+     * @param spec - Plugin function, extension object, preset, or ID
+     * @param options - Plugin options
+     * @returns This processor for chaining
+     */
+    use(spec: PluginSpec | Preset, options?: unknown): this;
+    /**
+     * Freeze the processor
+     *
+     * Returns a frozen processor that cannot be modified. Useful for
+     * reusing the same pipeline configuration across multiple documents.
+     *
+     * @returns A frozen copy of this processor
+     */
+    freeze(): FrozenStreamProcessor;
+    /**
+     * Stream a document as progressive sentence batches
+     *
+     * Processing phases:
+     * 1. All extensions with `streamingSupport !== 'chunk'` (i.e. `'none'`
+     *    or `'full'`, or unset) run their `transform`, `visit`, and
+     *    `enhanceMetadata` hooks on the **full** document.
+     * 2. The resulting document is split into sentence batches.
+     * 3. For each batch, extensions with `streamingSupport === 'chunk'`
+     *    run their `visit` and `enhanceMetadata` hooks.
+     * 4. A `ProcessedChunk` is yielded.
+     *
+     * Cancellation: break out of the `for await` loop at any time. The
+     * generator will stop without processing remaining chunks.
+     *
+     * @param document - GLOST document to stream
+     * @param streamOptions - Streaming options (batchSize etc.)
+     * @yields `ProcessedChunk` objects in document order
+     *
+     * @example
+     * ```typescript
+     * for await (const chunk of processor.stream(doc, { batchSize: 20 })) {
+     *   console.log(`para ${chunk.paragraphIndex} chunk ${chunk.chunkIndex}`);
+     *   if (chunk.isLast) console.log("done");
+     * }
+     * ```
+     */
+    stream(document: GLOSTRoot, streamOptions?: StreamOptions): AsyncGenerator<ProcessedChunk>;
+    private usePreset;
+    private resolveExtensions;
+    private resolvePlugin;
+    private isPreset;
+    private assertNotFrozen;
+}
+/**
+ * A frozen `GLOSTStreamProcessor` that cannot be modified.
+ *
+ * @since 0.7.0
+ */
+export type FrozenStreamProcessor = Omit<GLOSTStreamProcessor, "use" | "freeze"> & {
+    readonly frozen: true;
+};
+//# sourceMappingURL=stream-processor.d.ts.map

package/dist/stream-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-processor.d.ts","sourceRoot":"","sources":["../src/stream-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAO3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAMvE;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,wCAAwC;IACxC,SAAS,EAAE,aAAa,EAAE,CAAC;IAE3B;;;;;;OAMG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB,yDAAyD;IACzD,MAAM,EAAE,OAAO,CAAC;CACjB;AAMD;;;;;;;GAOG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,OAAO,CAAsD;IACrE,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,MAAM,CAAS;IAEvB;;;;OAIG;gBACS,OAAO,GAAE,gBAAqB;IAI1C;;;;;;OAMG;IACH,GAAG,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI;IAWvD;;;;;;;OAOG;IACH,MAAM,IAAI,qBAAqB;IAO/B;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACI,MAAM,CACX,QAAQ,EAAE,SAAS,EACnB,aAAa,CAAC,EAAE,aAAa,GAC5B,cAAc,CAAC,cAAc,CAAC;IAiGjC,OAAO,CAAC,SAAS;YAYH,iBAAiB;YAWjB,aAAa;IAsB3B,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,eAAe;CAKxB;AAMD;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,IAAI,CACtC,oBAAoB,EACpB,KAAK,GAAG,QAAQ,CACjB,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC"}

package/dist/stream-processor.js

@@ -0,0 +1,245 @@
+/**
+ * GLOST Stream Processor
+ *
+ * Streaming variant of GLOSTProcessor that yields processed sentence
+ * batches progressively using AsyncGenerator. Keeps the full document
+ * out of memory between chunks.
+ *
+ * Document-level transforms (extensions with streamingSupport !== 'chunk')
+ * run once on the full document before streaming begins. Chunk-compatible
+ * extensions (streamingSupport === 'chunk') then run on each batch.
+ *
+ * @packageDocumentation
+ *
+ * @example
+ * ```typescript
+ * import { GLOSTStreamProcessor } from "glost-processor";
+ *
+ * const processor = new GLOSTStreamProcessor()
+ *   .use(transcription)
+ *   .use(translation);
+ *
+ * for await (const chunk of processor.stream(document)) {
+ *   console.log(chunk.sentences, chunk.isLast);
+ * }
+ * ```
+ *
+ * @since 0.7.0
+ */
+import { processGLOSTWithExtensionsAsync, processGLOSTChunkAsync, extensionRegistry, } from "glost-extensions";
+// ============================================================================
+// GLOSTStreamProcessor
+// ============================================================================
+/**
+ * Streaming processor for GLOST documents
+ *
+ * Mirrors the `GLOSTProcessor` API (`.use()`, `.freeze()`) but adds a
+ * `.stream()` method that returns an `AsyncGenerator<ProcessedChunk>`.
+ *
+ * @since 0.7.0
+ */
+export class GLOSTStreamProcessor {
+    plugins = [];
+    options = {};
+    frozen = false;
+    /**
+     * Create a new stream processor instance
+     *
+     * @param options - Initial processor options
+     */
+    constructor(options = {}) {
+        this.options = { ...options };
+    }
+    /**
+     * Add a plugin, preset, or extension to the pipeline
+     *
+     * @param spec - Plugin function, extension object, preset, or ID
+     * @param options - Plugin options
+     * @returns This processor for chaining
+     */
+    use(spec, options) {
+        this.assertNotFrozen();
+        if (this.isPreset(spec)) {
+            return this.usePreset(spec);
+        }
+        this.plugins.push({ spec, options });
+        return this;
+    }
+    /**
+     * Freeze the processor
+     *
+     * Returns a frozen processor that cannot be modified. Useful for
+     * reusing the same pipeline configuration across multiple documents.
+     *
+     * @returns A frozen copy of this processor
+     */
+    freeze() {
+        const frozen = new GLOSTStreamProcessor(this.options);
+        frozen.plugins = [...this.plugins];
+        frozen.frozen = true;
+        return frozen;
+    }
+    /**
+     * Stream a document as progressive sentence batches
+     *
+     * Processing phases:
+     * 1. All extensions with `streamingSupport !== 'chunk'` (i.e. `'none'`
+     *    or `'full'`, or unset) run their `transform`, `visit`, and
+     *    `enhanceMetadata` hooks on the **full** document.
+     * 2. The resulting document is split into sentence batches.
+     * 3. For each batch, extensions with `streamingSupport === 'chunk'`
+     *    run their `visit` and `enhanceMetadata` hooks.
+     * 4. A `ProcessedChunk` is yielded.
+     *
+     * Cancellation: break out of the `for await` loop at any time. The
+     * generator will stop without processing remaining chunks.
+     *
+     * @param document - GLOST document to stream
+     * @param streamOptions - Streaming options (batchSize etc.)
+     * @yields `ProcessedChunk` objects in document order
+     *
+     * @example
+     * ```typescript
+     * for await (const chunk of processor.stream(doc, { batchSize: 20 })) {
+     *   console.log(`para ${chunk.paragraphIndex} chunk ${chunk.chunkIndex}`);
+     *   if (chunk.isLast) console.log("done");
+     * }
+     * ```
+     */
+    async *stream(document, streamOptions) {
+        const batchSize = streamOptions?.batchSize ?? 50;
+        const extensions = await this.resolveExtensions();
+        // Split extensions into doc-level and chunk-level
+        const docExtensions = extensions.filter((e) => e.streamingSupport !== "chunk");
+        const chunkExtensions = extensions.filter((e) => e.streamingSupport === "chunk");
+        // Phase 1: run doc-level transforms on the full document
+        let processedDoc = document;
+        if (docExtensions.length > 0) {
+            const { data: _data, ...extOptions } = this.options;
+            const result = await processGLOSTWithExtensionsAsync(processedDoc, docExtensions, extOptions);
+            processedDoc = result.document;
+        }
+        // Phase 2: collect all sentences grouped by paragraph index
+        const paragraphSentences = collectSentencesByParagraph(processedDoc);
+        if (paragraphSentences.length === 0) {
+            return;
+        }
+        const allChunks = [];
+        for (let pIdx = 0; pIdx < paragraphSentences.length; pIdx++) {
+            const sentences = paragraphSentences[pIdx];
+            let chunkIndex = 0;
+            for (let offset = 0; offset < sentences.length; offset += batchSize) {
+                allChunks.push({
+                    paragraphIndex: pIdx,
+                    chunkIndex,
+                    sentences: sentences.slice(offset, offset + batchSize),
+                });
+                chunkIndex++;
+            }
+        }
+        const totalChunks = allChunks.length;
+        // Phase 3: yield each chunk, optionally running chunk-level extensions
+        for (let i = 0; i < totalChunks; i++) {
+            const descriptor = allChunks[i];
+            let processedSentences = descriptor.sentences;
+            if (chunkExtensions.length > 0) {
+                const { data: _data, ...extOptions } = this.options;
+                processedSentences = await processGLOSTChunkAsync(processedSentences, chunkExtensions, extOptions);
+            }
+            yield {
+                sentences: processedSentences,
+                paragraphIndex: descriptor.paragraphIndex,
+                chunkIndex: descriptor.chunkIndex,
+                isLast: i === totalChunks - 1,
+            };
+        }
+    }
+    // =====================================================================
+    // Private helpers
+    // =====================================================================
+    usePreset(preset) {
+        for (const entry of preset.plugins) {
+            if (Array.isArray(entry)) {
+                const [plugin, opts] = entry;
+                this.use(plugin, opts);
+            }
+            else {
+                this.use(entry);
+            }
+        }
+        return this;
+    }
+    async resolveExtensions() {
+        const result = [];
+        for (const { spec, options } of this.plugins) {
+            const ext = await this.resolvePlugin(spec, options);
+            if (ext) {
+                result.push(ext);
+            }
+        }
+        return result;
+    }
+    async resolvePlugin(spec, options) {
+        if (typeof spec === "string") {
+            const ext = extensionRegistry.get(spec);
+            if (!ext) {
+                throw new Error(`Plugin "${spec}" not found in registry`);
+            }
+            return ext;
+        }
+        if (typeof spec === "function") {
+            const result = spec(options);
+            return result ?? null;
+        }
+        return spec;
+    }
+    isPreset(spec) {
+        return (spec !== null &&
+            typeof spec === "object" &&
+            "plugins" in spec &&
+            Array.isArray(spec.plugins));
+    }
+    assertNotFrozen() {
+        if (this.frozen) {
+            throw new Error("Cannot modify frozen stream processor");
+        }
+    }
+}
+// ============================================================================
+// Internal helpers
+// ============================================================================
+/**
+ * Collect all sentences from a GLOSTRoot, grouped by paragraph index.
+ *
+ * Only `SentenceNode` children of `ParagraphNode` children are
+ * collected. Sentences that appear directly under the root (without a
+ * wrapping paragraph) are collected as a single synthetic group at
+ * index 0.
+ *
+ * @internal
+ */
+function collectSentencesByParagraph(document) {
+    const groups = [];
+    // Sentences that sit directly under the root (no paragraph wrapper)
+    const rootSentences = [];
+    for (const child of document.children) {
+        if (child.type === "ParagraphNode" && "children" in child) {
+            const para = child;
+            const sentences = para.children.filter((c) => typeof c === "object" &&
+                c !== null &&
+                c.type === "SentenceNode");
+            if (sentences.length > 0) {
+                groups.push(sentences);
+            }
+        }
+        else if (child.type === "SentenceNode") {
+            rootSentences.push(child);
+        }
+    }
+    // Prepend root-level sentences as paragraph 0 (if any)
+    if (rootSentences.length > 0) {
+        groups.unshift(rootSentences);
+    }
+    return groups;
+}
+//# sourceMappingURL=stream-processor.js.map

package/dist/stream-processor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-processor.js","sourceRoot":"","sources":["../src/stream-processor.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glost-processor",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Unified-style processor API for GLOST documents",
   "type": "module",
   "main": "./dist/index.js",
@@ -26,8 +26,8 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "glost-core": "0.5.0",
-    "glost-extensions": "0.4.0"
+    "glost-extensions": "0.4.0",
+    "glost-core": "0.5.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",