@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/src/turtle/Manifest.ts

@@ -0,0 +1,215 @@
+/**
+ * A reader for W3C test-suite manifests (`manifest.ttl`) as used by the RDF,
+ * SPARQL, SHACL, ShEx and JSON-LD test suites.
+ *
+ * Manifests are parsed with the Turtle parser. `load` follows `mf:include`
+ * recursively; reading files is delegated to a caller-supplied function so
+ * that the module stays platform independent.
+ *
+ * @example
+ * ```ts
+ * import * as fs from 'node:fs'
+ * import { Effect } from 'effect'
+ * import { Manifest } from '@thomasfosterau/effect-rdf/turtle'
+ *
+ * const entries = Manifest.load(
+ *   'https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-turtle/manifest.ttl',
+ *   Manifest.fileReader('https://w3c.github.io/rdf-tests/', '/path/to/rdf-tests/', (path) =>
+ *     Effect.sync(() => fs.readFileSync(path, 'utf8')),
+ *   ),
+ * )
+ * ```
+ *
+ * @since 0.1.0
+ */
+import * as Dataset from '../Dataset.ts';
+import * as Namespace from '../Namespace.ts';
+import type * as Serialization from '../Serialization.ts';
+import * as Term from '../Term.ts';
+import { rdf, rdfs } from '../Vocab.ts';
+import * as Arr from 'effect/Array';
+import * as Effect from 'effect/Effect';
+import * as MutableHashSet from 'effect/MutableHashSet';
+import * as Option from 'effect/Option';
+import * as Turtle from './Turtle.ts';
+
+/**
+ * The W3C test manifest vocabulary.
+ *
+ * @since 0.1.0
+ * @category vocabularies
+ */
+export const mf = Namespace.vocabulary(
+  'http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#',
+  ['Manifest', 'entries', 'include', 'name', 'action', 'result', 'assumedTestBase'],
+);
+
+/**
+ * The RDF test vocabulary.
+ *
+ * @since 0.1.0
+ * @category vocabularies
+ */
+export const rdft = Namespace.make('http://www.w3.org/ns/rdftest#');
+
+/**
+ * A single test entry.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Entry {
+  /** The test IRI (or blank node key). */
+  readonly id: string;
+  /** The test node itself, for reading further properties from `dataset`. */
+  readonly node: Term.Subject;
+  /** The IRI of the test's `rdf:type`. */
+  readonly type: string;
+  /** The local name of the test type, e.g. `TestTurtleEval`. */
+  readonly kind: string;
+  /** `mf:name` (falls back to the local name of the test IRI). */
+  readonly name: string;
+  /** `rdfs:comment`, if any. */
+  readonly comment: Option.Option<string>;
+  /** The `mf:action` IRI, if the action is an IRI. */
+  readonly action: Option.Option<string>;
+  /** The `mf:result` IRI, if the result is an IRI. */
+  readonly result: Option.Option<string>;
+  /** The IRI of the manifest that lists this entry. */
+  readonly manifest: string;
+  /** The parsed manifest document. */
+  readonly dataset: Dataset.Dataset;
+}
+
+/**
+ * A parsed manifest.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Manifest {
+  readonly iri: string;
+  readonly label: Option.Option<string>;
+  readonly assumedTestBase: Option.Option<string>;
+  readonly entries: ReadonlyArray<Entry>;
+  readonly includes: ReadonlyArray<string>;
+  readonly dataset: Dataset.Dataset;
+}
+
+const localName = (iri: string): string => iri.replace(/^.*[#/]/, '');
+
+const iriOf = (term: Option.Option<Term.Object>): Option.Option<string> =>
+  Option.flatMap(term, (t) => (Term.isNamedNode(t) ? Option.some(t.value) : Option.none()));
+
+const stringOf = (term: Option.Option<Term.Object>): Option.Option<string> =>
+  Option.flatMap(term, (t) => (Term.isLiteral(t) ? Option.some(t.value) : Option.none()));
+
+/**
+ * Parses a manifest document. `iri` is the manifest's own IRI, used as the
+ * base IRI.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const parse = (
+  text: string,
+  iri: string,
+): Effect.Effect<Manifest, Serialization.RdfParseError> =>
+  Effect.map(Turtle.parse(text, { baseIri: iri }), ({ dataset }) => {
+    const subjects = Dataset.subjectsOf(dataset, rdf.type, mf.Manifest);
+    const manifest: Term.Subject =
+      subjects.find((s) => Term.isNamedNode(s) && s.value === iri) ??
+      subjects[0] ??
+      Term.namedNode(iri);
+    const listAt = (p: Term.NamedNode): ReadonlyArray<Term.Object> =>
+      Dataset.objectsOf(dataset, manifest, p).flatMap((head) =>
+        Option.getOrElse(Dataset.list(dataset, head), () => []),
+      );
+    const entries = listAt(mf.entries).flatMap((node): ReadonlyArray<Entry> => {
+      if (!Term.isResource(node)) return [];
+      const type = iriOf(Dataset.objectOf(dataset, node, rdf.type));
+      const id = Term.isNamedNode(node) ? node.value : node.key;
+      return [
+        {
+          id,
+          node,
+          type: Option.getOrElse(type, () => ''),
+          kind: Option.match(type, { onNone: () => '', onSome: localName }),
+          name: Option.getOrElse(stringOf(Dataset.objectOf(dataset, node, mf.name)), () =>
+            localName(id),
+          ),
+          comment: stringOf(Dataset.objectOf(dataset, node, rdfs.comment)),
+          action: iriOf(Dataset.objectOf(dataset, node, mf.action)),
+          result: iriOf(Dataset.objectOf(dataset, node, mf.result)),
+          manifest: iri,
+          dataset,
+        },
+      ];
+    });
+    return {
+      iri,
+      label: stringOf(Dataset.objectOf(dataset, manifest, rdfs.label)),
+      assumedTestBase: iriOf(Dataset.objectOf(dataset, manifest, mf.assumedTestBase)),
+      entries,
+      includes: listAt(mf.include).flatMap((t) => (Term.isNamedNode(t) ? [t.value] : [])),
+      dataset,
+    };
+  });
+
+/**
+ * Loads a manifest and, recursively, every manifest it includes, returning
+ * all entries (each manifest is read at most once).
+ *
+ * @since 0.1.0
+ * @category loading
+ */
+export const load = <E, R>(
+  iri: string,
+  read: (iri: string) => Effect.Effect<string, E, R>,
+): Effect.Effect<ReadonlyArray<Entry>, E | Serialization.RdfParseError, R> =>
+  Effect.suspend(() => {
+    const seen = MutableHashSet.empty<string>();
+    const entries: Array<Entry> = [];
+    // Breadth first: a manifest's entries, then those of each include in turn
+    const visit = (
+      queue: ReadonlyArray<string>,
+    ): Effect.Effect<ReadonlyArray<Entry>, E | Serialization.RdfParseError, R> => {
+      if (!Arr.isReadonlyArrayNonEmpty(queue)) return Effect.succeed(entries);
+      const [next, ...rest] = queue;
+      if (MutableHashSet.has(seen, next)) return visit(rest);
+      MutableHashSet.add(seen, next);
+      return read(next).pipe(
+        Effect.flatMap((text) => parse(text, next)),
+        Effect.flatMap((manifest) => {
+          entries.push(...manifest.entries);
+          return visit([...rest, ...manifest.includes]);
+        }),
+      );
+    };
+    return visit([iri]);
+  });
+
+/**
+ * Builds a `read` function for `load` that maps IRIs under `iriPrefix` to
+ * paths under `pathPrefix` and reads them with `readFile`.
+ *
+ * @since 0.1.0
+ * @category loading
+ */
+export const fileReader =
+  <E, R>(
+    iriPrefix: string,
+    pathPrefix: string,
+    readFile: (path: string) => Effect.Effect<string, E, R>,
+  ) =>
+  (iri: string): Effect.Effect<string, E, R> =>
+    readFile(toPath(iri, iriPrefix, pathPrefix));
+
+/**
+ * Maps an IRI under `iriPrefix` to a path under `pathPrefix`.
+ *
+ * @since 0.1.0
+ * @category loading
+ */
+export const toPath = (iri: string, iriPrefix: string, pathPrefix: string): string =>
+  iri.startsWith(iriPrefix) ? pathPrefix + iri.slice(iriPrefix.length) : iri;

package/src/turtle/TriG.ts

@@ -0,0 +1,158 @@
+/**
+ * RDF 1.2 TriG: Turtle extended with named graphs.
+ *
+ * Supports the same RDF 1.2 features as `Turtle`, plus `GRAPH` blocks and
+ * `{ ... }` default-graph blocks. The serializer writes default-graph
+ * triples at the top level followed by one block per named graph, with the
+ * same pretty-printing as the Turtle serializer.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from 'effect'
+ * import { TriG } from '@thomasfosterau/effect-rdf/turtle'
+ *
+ * const program = Effect.gen(function* () {
+ *   const { dataset, prefixes } = yield* TriG.parse(`
+ *     PREFIX ex: <http://example.org/>
+ *     ex:g { ex:s ex:p ex:o }
+ *   `)
+ *   return yield* TriG.serialize(dataset, { prefixes })
+ * })
+ * ```
+ *
+ * @since 0.1.0
+ */
+import * as Serialization from '../Serialization.ts';
+import type * as Term from '../Term.ts';
+import type * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import type * as Stream from 'effect/Stream';
+import * as internal from './internal/parse.ts';
+import * as internalSerialize from './internal/serialize.ts';
+
+/**
+ * The result of `parseQuads`: statements in document order with the
+ * document's prefixes and final base IRI.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type QuadsResult = internal.QuadsResult;
+
+/**
+ * Options for the TriG serializer.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type SerializeOptions = internalSerialize.SerializeOptions;
+
+/**
+ * @since 0.1.0
+ * @category formats
+ */
+export const format: Serialization.Format = Serialization.makeFormat({
+  name: 'TriG',
+  mediaType: 'application/trig',
+  extensions: ['trig'],
+  datasets: true,
+});
+
+// The span names are `TriG.parse`, `TriG.serialize`, …
+const syntax: internal.Syntax = {
+  name: 'TriG',
+  trig: true,
+  trace: Option.some({ module: 'TriG', format }),
+};
+
+/**
+ * Parses a TriG document, returning the dataset together with the declared
+ * prefixes and the final base IRI.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const parse = (
+  input: string,
+  options?: Serialization.ParseOptions,
+): Effect.Effect<Serialization.ParseResult, Serialization.RdfParseError> =>
+  internal.parse(syntax, input, options);
+
+/**
+ * Parses a TriG document into statements in document order.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const parseQuads = (
+  input: string,
+  options?: Serialization.ParseOptions,
+): Effect.Effect<QuadsResult, Serialization.RdfParseError> =>
+  internal.parseQuads(syntax, input, options);
+
+/**
+ * Parses a stream of text chunks incrementally. Statements are emitted as
+ * soon as they are complete (statements inside graph blocks individually);
+ * chunk boundaries may fall anywhere.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const parseStream: <E, R>(
+  input: Stream.Stream<string, E, R>,
+  options?: Serialization.ParseOptions,
+) => Stream.Stream<Term.Quad, Serialization.RdfParseError | E, R> = internal.parseStream(syntax);
+
+/**
+ * Serialises quads as pretty TriG. Fails for triple terms in the subject
+ * position (not expressible in TriG 1.2).
+ *
+ * @since 0.1.0
+ * @category serializing
+ */
+export const serialize = (
+  quads: Iterable<Term.Quad>,
+  options?: SerializeOptions,
+): Effect.Effect<string, Serialization.RdfSerializeError> =>
+  internalSerialize.serialize(syntax, quads, options);
+
+/**
+ * Serialises a stream of quads incrementally in constant memory. Only
+ * consecutive statements are grouped (a graph block is opened whenever the
+ * graph changes), and blank nodes keep their labels.
+ *
+ * @since 0.1.0
+ * @category serializing
+ */
+export const serializeStream: <E, R>(
+  quads: Stream.Stream<Term.Quad, E, R>,
+  options?: SerializeOptions,
+) => Stream.Stream<string, Serialization.RdfSerializeError | E, R> =
+  internalSerialize.serializeStream(syntax);
+
+/**
+ * @since 0.1.0
+ * @category parsing
+ */
+export const parser: Serialization.Parser = Serialization.makeParser({
+  format,
+  parse,
+  parseStream,
+});
+
+/**
+ * @since 0.1.0
+ * @category serializing
+ */
+export const serializer: Serialization.Serializer<SerializeOptions> = Serialization.makeSerializer({
+  format,
+  serialize,
+  serializeStream,
+});
+
+/**
+ * @since 0.1.0
+ * @category codecs
+ */
+export const codec: Serialization.Codec<Serialization.ParseOptions, SerializeOptions> =
+  Serialization.makeCodec(parser, serializer);

package/src/turtle/Turtle.ts

@@ -0,0 +1,166 @@
+/**
+ * RDF 1.2 Turtle: the terse RDF triple language.
+ *
+ * The parser supports the full RDF 1.2 grammar (triple terms `<<( s p o )>>`,
+ * reified triples `<< s p o ~ r >>`, annotations `{| ... |}`, `VERSION`,
+ * directional language tags) as well as RDF 1.1 documents, and reports the
+ * declared prefixes and final base IRI. `parseStream` parses incrementally,
+ * emitting statements as soon as they are complete.
+ *
+ * The serializer produces idiomatic output: prefixed names, `@base`
+ * relativisation, subject grouping with `;` and `,`, `a` for `rdf:type`,
+ * inline `[ ... ]` blank nodes, `( ... )` collections, numeric and boolean
+ * shorthand, annotation syntax for reified asserted triples, and a
+ * deterministic statement order.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from 'effect'
+ * import { PrefixMap } from '@thomasfosterau/effect-rdf'
+ * import { Turtle } from '@thomasfosterau/effect-rdf/turtle'
+ *
+ * const program = Effect.gen(function* () {
+ *   const { dataset, prefixes } = yield* Turtle.parse(`
+ *     PREFIX ex: <http://example.org/>
+ *     ex:alice a ex:Person ; ex:knows [ ex:name "Bob" ] .
+ *   `)
+ *   return yield* Turtle.serialize(dataset, { prefixes })
+ * })
+ * ```
+ *
+ * @since 0.1.0
+ */
+import * as Serialization from '../Serialization.ts';
+import type * as Term from '../Term.ts';
+import type * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import type * as Stream from 'effect/Stream';
+import * as internal from './internal/parse.ts';
+import * as internalSerialize from './internal/serialize.ts';
+
+/**
+ * The result of `parseQuads`: statements in document order with the
+ * document's prefixes and final base IRI.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type QuadsResult = internal.QuadsResult;
+
+/**
+ * Options for the Turtle serializer.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type SerializeOptions = internalSerialize.SerializeOptions;
+
+/**
+ * @since 0.1.0
+ * @category formats
+ */
+export const format: Serialization.Format = Serialization.makeFormat({
+  name: 'Turtle',
+  mediaType: 'text/turtle',
+  mediaTypes: ['text/turtle', 'application/x-turtle'],
+  extensions: ['ttl'],
+  datasets: false,
+});
+
+// The span names are `Turtle.parse`, `Turtle.serialize`, …
+const syntax: internal.Syntax = {
+  name: 'Turtle',
+  trig: false,
+  trace: Option.some({ module: 'Turtle', format }),
+};
+
+/**
+ * Parses a Turtle document, returning the dataset together with the
+ * declared prefixes and the final base IRI. Triples are placed in
+ * `options.graph` (the default graph when omitted).
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const parse = (
+  input: string,
+  options?: Serialization.ParseOptions,
+): Effect.Effect<Serialization.ParseResult, Serialization.RdfParseError> =>
+  internal.parse(syntax, input, options);
+
+/**
+ * Parses a Turtle document into statements in document order.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const parseQuads = (
+  input: string,
+  options?: Serialization.ParseOptions,
+): Effect.Effect<QuadsResult, Serialization.RdfParseError> =>
+  internal.parseQuads(syntax, input, options);
+
+/**
+ * Parses a stream of text chunks incrementally. Statements are emitted as
+ * soon as they are complete; chunk boundaries may fall anywhere.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+export const parseStream: <E, R>(
+  input: Stream.Stream<string, E, R>,
+  options?: Serialization.ParseOptions,
+) => Stream.Stream<Term.Quad, Serialization.RdfParseError | E, R> = internal.parseStream(syntax);
+
+/**
+ * Serialises triples as pretty Turtle. Fails for quads in named graphs and
+ * for triple terms in the subject position (not expressible in Turtle 1.2).
+ *
+ * @since 0.1.0
+ * @category serializing
+ */
+export const serialize = (
+  quads: Iterable<Term.Quad>,
+  options?: SerializeOptions,
+): Effect.Effect<string, Serialization.RdfSerializeError> =>
+  internalSerialize.serialize(syntax, quads, options);
+
+/**
+ * Serialises a stream of triples incrementally in constant memory. Only
+ * consecutive statements are grouped, and blank nodes keep their labels.
+ *
+ * @since 0.1.0
+ * @category serializing
+ */
+export const serializeStream: <E, R>(
+  quads: Stream.Stream<Term.Quad, E, R>,
+  options?: SerializeOptions,
+) => Stream.Stream<string, Serialization.RdfSerializeError | E, R> =
+  internalSerialize.serializeStream(syntax);
+
+/**
+ * @since 0.1.0
+ * @category parsing
+ */
+export const parser: Serialization.Parser = Serialization.makeParser({
+  format,
+  parse,
+  parseStream,
+});
+
+/**
+ * @since 0.1.0
+ * @category serializing
+ */
+export const serializer: Serialization.Serializer<SerializeOptions> = Serialization.makeSerializer({
+  format,
+  serialize,
+  serializeStream,
+});
+
+/**
+ * @since 0.1.0
+ * @category codecs
+ */
+export const codec: Serialization.Codec<Serialization.ParseOptions, SerializeOptions> =
+  Serialization.makeCodec(parser, serializer);

package/src/turtle/index.ts

@@ -0,0 +1,14 @@
+/**
+ * RDF 1.2 Turtle and TriG for `@thomasfosterau/effect-rdf`.
+ *
+ * @since 0.1.0
+ */
+
+/** @since 0.1.0 */
+export * as Grammar from './Grammar.ts';
+/** @since 0.1.0 */
+export * as Manifest from './Manifest.ts';
+/** @since 0.1.0 */
+export * as TriG from './TriG.ts';
+/** @since 0.1.0 */
+export * as Turtle from './Turtle.ts';

package/src/turtle/internal/loop.ts

@@ -0,0 +1,23 @@
+/**
+ * A loop as a function, for the scans that step a cursor until a condition
+ * holds (decoding an escape, walking a list, counting line breaks).
+ *
+ * @internal
+ */
+import * as Iterable from 'effect/Iterable';
+
+const BLOCK = 1024;
+
+/** `0 … BLOCK - 1`: the steps of one block run as an array scan, which engines optimise well. */
+const offsets: ReadonlyArray<number> = Array.from({ length: BLOCK }, (_, i) => i);
+
+/** The first step of each block after the first: `BLOCK, 2 * BLOCK, …`. */
+const blocks: Iterable<number> = Iterable.makeBy((b) => (b + 1) * BLOCK);
+
+/** Calls `step` with 0, 1, 2, … until it returns `false`. */
+export const loop = (step: (i: number) => boolean): void => {
+  // Most loops end within the first block, which needs no iterator
+  if (offsets.every((i) => step(i))) {
+    Iterable.some(blocks, (base) => offsets.some((i) => !step(base + i)));
+  }
+};

package/src/turtle/internal/parse.ts

@@ -0,0 +1,112 @@
+import * as Dataset from '../../Dataset.ts';
+import * as PrefixMap from '../../PrefixMap.ts';
+import * as Serialization from '../../Serialization.ts';
+import * as Term from '../../Term.ts';
+import * as Arr from 'effect/Array';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import * as Predicate from 'effect/Predicate';
+import * as Stream from 'effect/Stream';
+import { SyntaxFailure, TurtleParser } from './parser.ts';
+
+/** @internal */
+export interface Syntax {
+  readonly name: string;
+  readonly trig: boolean;
+  /** The span prefix and format for tracing (`<module>.parse`, …); untraced when `None`. */
+  readonly trace: Option.Option<Serialization.SpanTarget>;
+}
+
+/**
+ * The result of parsing a document into quads in document order.
+ *
+ * @internal
+ */
+export interface QuadsResult {
+  readonly quads: ReadonlyArray<Term.Quad>;
+  readonly prefixes: PrefixMap.PrefixMap;
+  readonly baseIri: string | undefined;
+}
+
+const makeParser = (syntax: Syntax, options?: Serialization.ParseOptions): TurtleParser =>
+  new TurtleParser({
+    trig: syntax.trig,
+    baseIri: Option.fromUndefinedOr(options?.baseIri),
+    blankNodePrefix: options?.blankNodePrefix ?? Serialization.freshBlankNodePrefix(),
+    graph: (syntax.trig ? undefined : options?.graph) ?? Term.defaultGraph,
+  });
+
+/**
+ * Maps what a parse threw — a `SyntaxFailure`, or a defect as an `Error` or
+ * its string form — to an `RdfParseError`.
+ */
+const toParseError = (syntax: Syntax, error: Error | string): Serialization.RdfParseError =>
+  error instanceof SyntaxFailure
+    ? new Serialization.RdfParseError({
+        format: syntax.name,
+        message: error.message,
+        line: error.line,
+        column: error.column,
+      })
+    : new Serialization.RdfParseError({
+        format: syntax.name,
+        message: Predicate.isString(error) ? error : error.message,
+      });
+
+/** @internal */
+export const parseQuads = (
+  syntax: Syntax,
+  input: string,
+  options?: Serialization.ParseOptions,
+): Effect.Effect<QuadsResult, Serialization.RdfParseError> =>
+  Effect.try({
+    try: () => {
+      const parser = makeParser(syntax, options);
+      const quads = parser.parseDocument(input);
+      return {
+        quads,
+        prefixes: PrefixMap.make(parser.prefixes),
+        baseIri: Option.getOrUndefined(parser.base),
+      };
+    },
+    catch: (error) => toParseError(syntax, Predicate.isError(error) ? error : String(error)),
+  });
+
+/** @internal */
+export const parse = (
+  syntax: Syntax,
+  input: string,
+  options?: Serialization.ParseOptions,
+): Effect.Effect<Serialization.ParseResult, Serialization.RdfParseError> =>
+  Effect.map(parseQuads(syntax, input, options), (result) => ({
+    dataset: Dataset.fromIterable(result.quads),
+    prefixes: result.prefixes,
+    baseIri: result.baseIri,
+  })).pipe(Serialization.withParseSpan(Option.getOrUndefined(syntax.trace), input));
+
+const END: unique symbol = Symbol('end');
+
+/** @internal */
+export const parseStream =
+  (syntax: Syntax) =>
+  <E, R>(
+    input: Stream.Stream<string, E, R>,
+    options?: Serialization.ParseOptions,
+  ): Stream.Stream<Term.Quad, Serialization.RdfParseError | E, R> =>
+    Stream.suspend(() => {
+      const parser = makeParser(syntax, options);
+      return Stream.concat(input, Stream.succeed(END)).pipe(
+        Stream.mapAccumArrayEffect(
+          () => undefined,
+          (_, chunks) =>
+            Effect.try({
+              try: (): readonly [undefined, ReadonlyArray<Term.Quad>] => [
+                undefined,
+                Arr.flatMap(chunks, (chunk) => (chunk === END ? parser.end() : parser.feed(chunk))),
+              ],
+              catch: (error) =>
+                toParseError(syntax, Predicate.isError(error) ? error : String(error)),
+            }),
+        ),
+      );
+    }).pipe(Serialization.withStreamSpan(Option.getOrUndefined(syntax.trace), 'parseStream'));