@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Serialization-Df8iVauT.d.mts

@@ -0,0 +1,392 @@
+import { _ as Quad, o as Graph } from "./Term-B_4ezyXq.mjs";
+import { n as Dataset } from "./Dataset-DS3ESOcO.mjs";
+import { t as PrefixMap } from "./PrefixMap-BMlXrWNd.mjs";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Context from "effect/Context";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as Stream from "effect/Stream";
+import * as PlatformError from "effect/PlatformError";
+declare namespace Serialization_d_exports {
+  export { AcceptEntry, BytesOptions, Codec, Format, Formats, ParseOptions, ParseResult, Parser, RdfParseError, RdfSerializeError, ReadFileOptions, SerializeOptions, Serializer, SpanTarget, WriteFileOptions, formatError, freshBlankNodePrefix, layer, makeCodec, makeFormat, makeParser, makeSerializer, negotiate, parseAccept, parseBytes, parseBytesDocument, parserFor, parserForExtension, readFile, serializeBytes, serializerFor, serializerForExtension, toSchema, withParseSpan, withSerializeSpan, withStreamSpan, writeFile };
+}
+declare const RdfParseError_base: Schema.Class<RdfParseError, Schema.TaggedStruct<"RdfParseError", {
+  readonly format: Schema.String;
+  readonly message: Schema.String;
+  readonly line: Schema.optional<Schema.Number>;
+  readonly column: Schema.optional<Schema.Number>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A syntax or semantic error encountered while parsing an RDF document.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+declare class RdfParseError extends RdfParseError_base {}
+declare const RdfSerializeError_base: Schema.Class<RdfSerializeError, Schema.TaggedStruct<"RdfSerializeError", {
+  readonly format: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * An error encountered while serialising quads, e.g. a quad that cannot be
+ * represented in the target syntax (a named graph in Turtle).
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+declare class RdfSerializeError extends RdfSerializeError_base {}
+/**
+ * Metadata describing an RDF concrete syntax.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Format {
+  /** Human-readable name, e.g. `"Turtle"`. */
+  readonly name: string;
+  /** The preferred media type. */
+  readonly mediaType: string;
+  /** All media types (including the preferred one) that identify the syntax. */
+  readonly mediaTypes: ReadonlyArray<string>;
+  /** File extensions without the leading dot. */
+  readonly extensions: ReadonlyArray<string>;
+  /** Whether the syntax can represent named graphs. */
+  readonly datasets: boolean;
+}
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const makeFormat: (format: Omit<Format, "mediaTypes"> & {
+  readonly mediaTypes?: ReadonlyArray<string>;
+}) => Format;
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface ParseOptions {
+  /** The base IRI against which relative IRIs are resolved. */
+  readonly baseIri?: string | undefined;
+  /**
+   * The graph in which triples are placed when parsing a triples-only syntax.
+   * Defaults to the default graph.
+   */
+  readonly graph?: Graph | undefined;
+  /**
+   * Prefix for generated blank node labels. Defaults to a fresh prefix per
+   * document so that blank nodes from different documents never clash.
+   */
+  readonly blankNodePrefix?: string | undefined;
+}
+/**
+ * The result of parsing a complete document.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ParseResult {
+  readonly dataset: Dataset;
+  /** Prefixes declared by the document, if the syntax supports them. */
+  readonly prefixes: PrefixMap;
+  /** The final base IRI of the document, if any. */
+  readonly baseIri: string | undefined;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface Parser<Options extends ParseOptions = ParseOptions> {
+  readonly format: Format;
+  /** Parses a complete document. */
+  readonly parse: (input: string, options?: Options) => Effect.Effect<ParseResult, RdfParseError>;
+  /** Parses a stream of text chunks into a stream of quads. */
+  readonly parseStream: <E, R>(input: Stream.Stream<string, E, R>, options?: Options) => Stream.Stream<Quad, RdfParseError | E, R>;
+}
+/**
+ * Builds a `Parser`. When `parseStream` is not provided the stream is
+ * buffered and parsed as a whole.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const makeParser: <Options extends ParseOptions = ParseOptions>(options: {
+  readonly format: Format;
+  readonly parse: (input: string, options?: Options) => Effect.Effect<ParseResult, RdfParseError>;
+  readonly parseStream?: Parser<Options>["parseStream"];
+}) => Parser<Options>;
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface SerializeOptions {
+  /** Prefixes to use for abbreviating IRIs, if the syntax supports them. */
+  readonly prefixes?: PrefixMap | undefined;
+  /** The base IRI used to relativise IRIs, if the syntax supports it. */
+  readonly baseIri?: string | undefined;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface Serializer<Options extends SerializeOptions = SerializeOptions> {
+  readonly format: Format;
+  /** Serialises quads to a complete document. */
+  readonly serialize: (quads: Iterable<Quad>, options?: Options) => Effect.Effect<string, RdfSerializeError>;
+  /** Serialises a stream of quads to a stream of text chunks. */
+  readonly serializeStream: <E, R>(quads: Stream.Stream<Quad, E, R>, options?: Options) => Stream.Stream<string, RdfSerializeError | E, R>;
+}
+/**
+ * Builds a `Serializer`. When `serializeStream` is not provided the stream is
+ * buffered and serialised as a whole.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const makeSerializer: <Options extends SerializeOptions = SerializeOptions>(options: {
+  readonly format: Format;
+  readonly serialize: (quads: Iterable<Quad>, options?: Options) => Effect.Effect<string, RdfSerializeError>;
+  readonly serializeStream?: Serializer<Options>["serializeStream"];
+}) => Serializer<Options>;
+/**
+ * A parser and serializer for the same syntax.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Codec<ParseOpts extends ParseOptions = ParseOptions, SerializeOpts extends SerializeOptions = SerializeOptions> extends Parser<ParseOpts>, Serializer<SerializeOpts> {
+  /** A schema transforming documents (`string`) to `Dataset`s and back. */
+  readonly schema: Schema.Codec<Dataset, string>;
+}
+/**
+ * Combines a parser and serializer into a `Codec`.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const makeCodec: <ParseOpts extends ParseOptions, SerializeOpts extends SerializeOptions>(parser: Parser<ParseOpts>, serializer: Serializer<SerializeOpts>) => Codec<ParseOpts, SerializeOpts>;
+/**
+ * Builds a `Schema` that decodes documents to datasets with `parser` and
+ * encodes datasets with `serializer`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const toSchema: (parser: Parser<any>, serializer: Serializer<any>) => Schema.Codec<Dataset, string>;
+/**
+ * Formats a parse error with its position.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+declare const formatError: (error: RdfParseError) => string;
+declare const Formats_base: Context.ServiceClass<Formats, "@thomasfosterau/effect-rdf/Formats", {
+  readonly parsers: ReadonlyArray<Parser<any>>;
+  readonly serializers: ReadonlyArray<Serializer<any>>;
+}>;
+/**
+ * A registry of available parsers and serializers, used for media-type
+ * lookup and HTTP content negotiation.
+ *
+ * @since 0.1.0
+ * @category services
+ */
+declare class Formats extends Formats_base {}
+/**
+ * Creates a `Formats` layer from codecs, parsers and serializers.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const layer: (...entries: ReadonlyArray<Codec<any, any> | Parser<any> | Serializer<any>>) => Layer.Layer<Formats>;
+/**
+ * Finds a parser for a media type (parameters such as `charset` are ignored).
+ *
+ * @since 0.1.0
+ * @category lookup
+ */
+declare const parserFor: (formats: Formats["Service"], mediaType: string) => Option.Option<Parser<any>>;
+/**
+ * Finds a serializer for a media type.
+ *
+ * @since 0.1.0
+ * @category lookup
+ */
+declare const serializerFor: (formats: Formats["Service"], mediaType: string) => Option.Option<Serializer<any>>;
+/**
+ * Finds a parser for a file extension (with or without leading dot).
+ *
+ * @since 0.1.0
+ * @category lookup
+ */
+declare const parserForExtension: (formats: Formats["Service"], extension: string) => Option.Option<Parser<any>>;
+/**
+ * Finds a serializer for a file extension (with or without leading dot).
+ *
+ * @since 0.1.0
+ * @category lookup
+ */
+declare const serializerForExtension: (formats: Formats["Service"], extension: string) => Option.Option<Serializer<any>>;
+/**
+ * A parsed `Accept` header entry.
+ *
+ * @since 0.1.0
+ * @category negotiation
+ */
+interface AcceptEntry {
+  readonly mediaType: string;
+  readonly q: number;
+}
+/**
+ * Parses an HTTP `Accept` header, sorted by preference.
+ *
+ * @since 0.1.0
+ * @category negotiation
+ */
+declare const parseAccept: (header: string) => ReadonlyArray<AcceptEntry>;
+/**
+ * Selects the best of `available` media types for an `Accept` header.
+ * Returns the first available type when the header is empty or absent.
+ *
+ * @since 0.1.0
+ * @category negotiation
+ */
+declare const negotiate: (accept: string | undefined, available: ReadonlyArray<string>) => Option.Option<string>;
+/**
+ * Generates a fresh blank node label prefix for a parsed document.
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const freshBlankNodePrefix: () => string;
+/**
+ * Options for reading bytes: a parser's options plus the text encoding.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface BytesOptions {
+  /**
+   * The character encoding of the input, as in a `charset` media-type
+   * parameter. Defaults to UTF-8, which is validated strictly; a leading byte
+   * order mark is dropped.
+   */
+  readonly charset?: string | undefined;
+}
+/**
+ * Parses a stream of bytes (from `FileSystem.stream`, an HTTP body, a socket
+ * or a child process) into a stream of quads. The bytes are decoded as UTF-8
+ * by default (or as `options.charset`), across chunk boundaries; ill-formed
+ * input fails with an `RdfParseError` at the line and column of the bad
+ * byte, never a defect.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parseBytes: <Options extends ParseOptions, E, R>(parser: Parser<Options>, input: Stream.Stream<Uint8Array, E, R>, options?: Options & BytesOptions) => Stream.Stream<Quad, RdfParseError | E, R>;
+/**
+ * Decodes a complete document's bytes as `parseBytes` does, then parses it
+ * with `parser.parse` (so the result keeps the document's prefixes and base).
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parseBytesDocument: <Options extends ParseOptions>(parser: Parser<Options>, input: Uint8Array, options?: Options & BytesOptions) => Effect.Effect<ParseResult, RdfParseError>;
+/**
+ * Serialises quads to a stream of UTF-8 bytes.
+ *
+ * @since 0.1.0
+ * @category serializing
+ */
+declare const serializeBytes: <Options extends SerializeOptions>(serializer: Serializer<Options>, quads: Iterable<Quad>, options?: Options) => Stream.Stream<Uint8Array, RdfSerializeError>;
+/**
+ * Options for `readFile`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ReadFileOptions extends ParseOptions, BytesOptions {
+  /** The parser to use; otherwise one is chosen by `mediaType` or the file extension. */
+  readonly parser?: Parser<any> | undefined;
+  /** A media type to find the parser by in the `Formats` service. */
+  readonly mediaType?: string | undefined;
+}
+/**
+ * Options for `writeFile`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface WriteFileOptions extends SerializeOptions {
+  /** The serializer to use; otherwise one is chosen by `mediaType` or the file extension. */
+  readonly serializer?: Serializer<any> | undefined;
+  /** A media type to find the serializer by in the `Formats` service. */
+  readonly mediaType?: string | undefined;
+}
+/**
+ * Reads an RDF file through Effect's platform-agnostic `FileSystem` (the
+ * consumer provides `NodeFileSystem`, Bun or another layer). The parser is
+ * `options.parser`, or is looked up in the `Formats` service by
+ * `options.mediaType` or the file extension. Relative IRIs resolve against
+ * the file's `file:` URL unless `options.baseIri` is given.
+ *
+ * @since 0.1.0
+ * @category files
+ */
+declare const readFile: (path: string, options?: ReadFileOptions) => Effect.Effect<ParseResult, RdfParseError | PlatformError.PlatformError, FileSystem.FileSystem | Path.Path>;
+/**
+ * Writes quads to an RDF file through Effect's `FileSystem`, as UTF-8. The
+ * serializer is `options.serializer`, or is looked up in the `Formats`
+ * service by `options.mediaType` or the file extension.
+ *
+ * @since 0.1.0
+ * @category files
+ */
+declare const writeFile: (path: string, quads: Iterable<Quad>, options?: WriteFileOptions) => Effect.Effect<void, RdfSerializeError | PlatformError.PlatformError, FileSystem.FileSystem | Path.Path>;
+/**
+ * What a syntax's spans are named after: `<module>.<operation>` (e.g.
+ * `Turtle.parse`), with the format's name and media type as attributes.
+ *
+ * @since 0.1.0
+ * @category tracing
+ */
+interface SpanTarget {
+  readonly module: string;
+  readonly format: Format;
+}
+/**
+ * Wraps a whole-document parse in a span named `<module>.<operation>`
+ * (`operation` defaults to `parse`), with the format, media type and input
+ * length in characters as attributes and the number of statements parsed
+ * (`rdf.quads`, which counts a statement the document repeats each time) on
+ * completion. The input text itself is never recorded.
+ * With no target the effect is returned unchanged.
+ *
+ * @since 0.1.0
+ * @category tracing
+ */
+declare const withParseSpan: (target: SpanTarget | undefined, input: string, operation?: string) => <A extends ParseResult, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Wraps a whole-document serialisation in a span named
+ * `<module>.serialize`, with the format and media type as attributes and the
+ * output length in characters (`rdf.output.length`) on completion. With no
+ * target the effect is returned unchanged.
+ *
+ * @since 0.1.0
+ * @category tracing
+ */
+declare const withSerializeSpan: (target: SpanTarget | undefined) => <E, R>(self: Effect.Effect<string, E, R>) => Effect.Effect<string, E, R>;
+/**
+ * Wraps a streaming parse or serialisation in a span named
+ * `<module>.<operation>` (e.g. `Turtle.parseStream`) that lasts while the
+ * stream runs, with the format and media type as attributes. Nothing is
+ * recorded per element. With no target the stream is returned unchanged.
+ *
+ * @since 0.1.0
+ * @category tracing
+ */
+declare const withStreamSpan: (target: SpanTarget | undefined, operation: "parseStream" | "serializeStream") => <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R>;
+export { readFile as A, makeSerializer as C, parseBytesDocument as D, parseBytes as E, withParseSpan as F, withSerializeSpan as I, withStreamSpan as L, serializerFor as M, serializerForExtension as N, parserFor as O, toSchema as P, writeFile as R, makeParser as S, parseAccept as T, formatError as _, Formats as a, makeCodec as b, Parser as c, ReadFileOptions as d, Serialization_d_exports as f, WriteFileOptions as g, SpanTarget as h, Format as i, serializeBytes as j, parserForExtension as k, RdfParseError as l, Serializer as m, BytesOptions as n, ParseOptions as o, SerializeOptions as p, Codec as r, ParseResult as s, AcceptEntry as t, RdfSerializeError as u, freshBlankNodePrefix as v, negotiate as w, makeFormat as x, layer as y };
+//# sourceMappingURL=Serialization-Df8iVauT.d.mts.map

package/dist/Serialization.d.mts

@@ -0,0 +1,2 @@
+import { A as readFile, C as makeSerializer, D as parseBytesDocument, E as parseBytes, F as withParseSpan, I as withSerializeSpan, L as withStreamSpan, M as serializerFor, N as serializerForExtension, O as parserFor, P as toSchema, R as writeFile, S as makeParser, T as parseAccept, _ as formatError, a as Formats, b as makeCodec, c as Parser, d as ReadFileOptions, g as WriteFileOptions, h as SpanTarget, i as Format, j as serializeBytes, k as parserForExtension, l as RdfParseError, m as Serializer, n as BytesOptions, o as ParseOptions, p as SerializeOptions, r as Codec, s as ParseResult, t as AcceptEntry, u as RdfSerializeError, v as freshBlankNodePrefix, w as negotiate, x as makeFormat, y as layer } from "./Serialization-Df8iVauT.mjs";
+export { AcceptEntry, BytesOptions, Codec, Format, Formats, ParseOptions, ParseResult, Parser, RdfParseError, RdfSerializeError, ReadFileOptions, SerializeOptions, Serializer, SpanTarget, WriteFileOptions, formatError, freshBlankNodePrefix, layer, makeCodec, makeFormat, makeParser, makeSerializer, negotiate, parseAccept, parseBytes, parseBytesDocument, parserFor, parserForExtension, readFile, serializeBytes, serializerFor, serializerForExtension, toSchema, withParseSpan, withSerializeSpan, withStreamSpan, writeFile };

package/dist/Serialization.mjs

@@ -0,0 +1 @@
+export { t as Formats, n as RdfParseError, r as RdfSerializeError, a as formatError, o as freshBlankNodePrefix, s as layer, c as makeCodec, l as makeFormat, u as makeParser, d as makeSerializer, f as negotiate, p as parseAccept, m as parseBytes, h as parseBytesDocument, g as parserFor, _ as parserForExtension, v as readFile, y as serializeBytes, b as serializerFor, x as serializerForExtension, S as toSchema, C as withParseSpan, w as withSerializeSpan, T as withStreamSpan, E as writeFile } from "./Serialization-DP9H5bYQ.mjs";

package/dist/ServerFormats-CrRnjjf6.mjs

@@ -0,0 +1,64 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { b as serializerFor, f as negotiate, s as layer$1 } from "./Serialization-DP9H5bYQ.mjs";
+import { n as codec } from "./JsonLd-DOwS2FHg.mjs";
+import { n as codec$1 } from "./N3-BzyV-KIH.mjs";
+import { n as codec$2 } from "./NQuads-C1VBOJ3-.mjs";
+import { n as codec$3 } from "./NTriples-D-kLSEAf.mjs";
+import { p as codec$4 } from "./RdfJson-BNocgW4f.mjs";
+import { n as codec$5 } from "./RdfXml-DJ9G4gOq.mjs";
+import { n as codec$6 } from "./Turtle-CZVUOtwl.mjs";
+import { n as codec$7 } from "./TriG-BkqtqZ6Y.mjs";
+import * as Option from "effect/Option";
+// src/sparql/ServerFormats.ts
+var ServerFormats_exports = /* @__PURE__ */ __exportAll({
+	codecs: () => codecs,
+	layer: () => layer,
+	negotiateSerializer: () => negotiateSerializer,
+	serializerMediaTypes: () => serializerMediaTypes
+});
+/**
+* The default codecs, in order of preference for content negotiation.
+*
+* @since 0.1.0
+* @category formats
+*/
+const codecs = [
+	codec$6,
+	codec$3,
+	codec$5,
+	codec,
+	codec$1,
+	codec$7,
+	codec$2,
+	codec$4
+];
+/**
+* A `Formats` layer with the default codecs.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layer = layer$1(...codecs);
+/**
+* The media types of a set of serializers, in order.
+*
+* @since 0.1.0
+* @category negotiation
+*/
+const serializerMediaTypes = (formats) => formats.serializers.flatMap((s) => s.format.mediaTypes);
+/**
+* Chooses a serializer for an `Accept` header (the first registered
+* serializer when the header is absent or `*` / `*`).
+*
+* @since 0.1.0
+* @category negotiation
+*/
+const negotiateSerializer = (formats, accept) => {
+	const mediaType = negotiate(accept, serializerMediaTypes(formats));
+	if (Option.isNone(mediaType)) return void 0;
+	const serializer = serializerFor(formats, mediaType.value);
+	return Option.getOrUndefined(serializer);
+};
+export { serializerMediaTypes as a, negotiateSerializer as i, codecs as n, layer as r, ServerFormats_exports as t };
+
+//# sourceMappingURL=ServerFormats-CrRnjjf6.mjs.map

package/dist/ServerFormats-CrRnjjf6.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerFormats-CrRnjjf6.mjs","names":["Turtle.codec","NTriples.codec","RdfXml.codec","JsonLd.codec","N3.codec","TriG.codec","NQuads.codec","RdfJson.codec","Serialization.layer","Serialization.negotiate","Serialization.serializerFor"],"sources":["../src/sparql/ServerFormats.ts"],"sourcesContent":["/**\n * The RDF syntaxes the server reads and writes by default: Turtle,\n * N-Triples, RDF/XML, JSON-LD, N3, TriG, N-Quads and RDF/JSON, registered in\n * the core `Serialization.Formats` service.\n *\n * Graph Store request bodies are parsed with the parser registered for their\n * `Content-Type`, and `CONSTRUCT` / `DESCRIBE` results and Graph Store\n * responses are serialised with the serializer selected by content\n * negotiation, in the order of `codecs` (the first one is the default).\n *\n * @since 0.1.0\n */\nimport type * as Layer from 'effect/Layer';\nimport * as Option from 'effect/Option';\nimport * as Serialization from '../Serialization.ts';\nimport * as JsonLd from '../jsonld/JsonLd.ts';\nimport * as N3 from '../n3/N3.ts';\nimport * as NQuads from '../ntriples/NQuads.ts';\nimport * as NTriples from '../ntriples/NTriples.ts';\nimport * as RdfJson from '../rdfjson/RdfJson.ts';\nimport * as RdfXml from '../rdfxml/RdfXml.ts';\nimport * as TriG from '../turtle/TriG.ts';\nimport * as Turtle from '../turtle/Turtle.ts';\n\n/**\n * The default codecs, in order of preference for content negotiation.\n *\n * @since 0.1.0\n * @category formats\n */\nexport const codecs: ReadonlyArray<Serialization.Codec<any, any>> = [\n  Turtle.codec,\n  NTriples.codec,\n  RdfXml.codec,\n  JsonLd.codec,\n  N3.codec,\n  TriG.codec,\n  NQuads.codec,\n  RdfJson.codec,\n];\n\n/**\n * A `Formats` layer with the default codecs.\n *\n * @since 0.1.0\n * @category layers\n */\nexport const layer: Layer.Layer<Serialization.Formats> = Serialization.layer(...codecs);\n\n/**\n * The media types of a set of serializers, in order.\n *\n * @since 0.1.0\n * @category negotiation\n */\nexport const serializerMediaTypes = (\n  formats: Serialization.Formats['Service'],\n): ReadonlyArray<string> => formats.serializers.flatMap((s) => s.format.mediaTypes);\n\n/**\n * Chooses a serializer for an `Accept` header (the first registered\n * serializer when the header is absent or `*` / `*`).\n *\n * @since 0.1.0\n * @category negotiation\n */\nexport const negotiateSerializer = (\n  formats: Serialization.Formats['Service'],\n  accept: string | undefined,\n): Serialization.Serializer<any> | undefined => {\n  const mediaType = Serialization.negotiate(accept, serializerMediaTypes(formats));\n  if (Option.isNone(mediaType)) return undefined;\n  const serializer = Serialization.serializerFor(formats, mediaType.value);\n  return Option.getOrUndefined(serializer);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,SAAuD;CAClEA;CACAC;CACAC;CACAC;CACAC;CACAC;CACAC;CACAC;AACF;;;;;;;AAQA,MAAa,QAA4CC,QAAoB,GAAG,MAAM;;;;;;;AAQtF,MAAa,wBACX,YAC0B,QAAQ,YAAY,SAAS,MAAM,EAAE,OAAO,UAAU;;;;;;;;AASlF,MAAa,uBACX,SACA,WAC8C;CAC9C,MAAM,YAAYC,UAAwB,QAAQ,qBAAqB,OAAO,CAAC;CAC/E,IAAI,OAAO,OAAO,SAAS,GAAG,OAAO,KAAA;CACrC,MAAM,aAAaC,cAA4B,SAAS,UAAU,KAAK;CACvE,OAAO,OAAO,eAAe,UAAU;AACzC"}

package/dist/ServerFormats-DjC9NsO_.d.mts

@@ -0,0 +1,36 @@
+import { a as Formats, m as Serializer, r as Codec } from "./Serialization-Df8iVauT.mjs";
+import * as Layer from "effect/Layer";
+declare namespace ServerFormats_d_exports {
+  export { codecs, layer, negotiateSerializer, serializerMediaTypes };
+}
+/**
+ * The default codecs, in order of preference for content negotiation.
+ *
+ * @since 0.1.0
+ * @category formats
+ */
+declare const codecs: ReadonlyArray<Codec<any, any>>;
+/**
+ * A `Formats` layer with the default codecs.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const layer: Layer.Layer<Formats>;
+/**
+ * The media types of a set of serializers, in order.
+ *
+ * @since 0.1.0
+ * @category negotiation
+ */
+declare const serializerMediaTypes: (formats: Formats["Service"]) => ReadonlyArray<string>;
+/**
+ * Chooses a serializer for an `Accept` header (the first registered
+ * serializer when the header is absent or `*` / `*`).
+ *
+ * @since 0.1.0
+ * @category negotiation
+ */
+declare const negotiateSerializer: (formats: Formats["Service"], accept: string | undefined) => Serializer<any> | undefined;
+export { serializerMediaTypes as a, negotiateSerializer as i, codecs as n, layer as r, ServerFormats_d_exports as t };
+//# sourceMappingURL=ServerFormats-DjC9NsO_.d.mts.map

package/dist/ServiceDescription-BERsvg-k.d.mts

@@ -0,0 +1,54 @@
+import { _ as Quad, d as NamedNode, t as BlankNode } from "./Term-B_4ezyXq.mjs";
+import { a as Formats } from "./Serialization-Df8iVauT.mjs";
+declare namespace ServiceDescription_d_exports {
+  export { DescriptionOptions, FormatIris, SD, describe, formatIris };
+}
+/**
+ * The service description namespace.
+ *
+ * @since 0.1.0
+ * @category vocabulary
+ */
+declare const SD = "http://www.w3.org/ns/sparql-service-description#";
+/**
+ * A table from media type to its `http://www.w3.org/ns/formats/` IRI.
+ *
+ * @since 0.1.0
+ * @category vocabulary
+ */
+interface FormatIris {
+  readonly [mediaType: string]: string;
+}
+/**
+ * The `http://www.w3.org/ns/formats/` IRIs of well-known media types.
+ *
+ * @since 0.1.0
+ * @category vocabulary
+ */
+declare const formatIris: FormatIris;
+/**
+ * What the description advertises.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface DescriptionOptions {
+  /** The query endpoint URL. */
+  readonly endpoint: string;
+  /** The update endpoint URL, when updates are enabled. */
+  readonly updateEndpoint: string | undefined;
+  readonly formats: Formats['Service'];
+  readonly unionDefaultGraph: boolean;
+  readonly federation: boolean;
+  /** Named graphs of the default dataset to list. */
+  readonly namedGraphs: ReadonlyArray<NamedNode | BlankNode>;
+}
+/**
+ * Builds the service description as triples.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const describe: (options: DescriptionOptions) => ReadonlyArray<Quad>;
+export { describe as a, ServiceDescription_d_exports as i, FormatIris as n, formatIris as o, SD as r, DescriptionOptions as t };
+//# sourceMappingURL=ServiceDescription-BERsvg-k.d.mts.map

package/dist/ServiceDescription-Dq5hxeGy.mjs

@@ -0,0 +1,97 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { Q as quad, T as blankNode, Z as namedNode } from "./Term-CFLG1qu4.mjs";
+import { d as codecs } from "./Results-peJjGA2V.mjs";
+import * as Arr from "effect/Array";
+// src/sparql/ServiceDescription.ts
+/**
+* SPARQL 1.1 Service Description: the RDF description of the endpoint
+* returned for a `GET` request without a query.
+*
+* @since 0.1.0
+*/
+var ServiceDescription_exports = /* @__PURE__ */ __exportAll({
+	SD: () => SD,
+	describe: () => describe,
+	formatIris: () => formatIris
+});
+/**
+* The service description namespace.
+*
+* @since 0.1.0
+* @category vocabulary
+*/
+const SD = "http://www.w3.org/ns/sparql-service-description#";
+const RDF_TYPE = namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type");
+const FORMATS = "http://www.w3.org/ns/formats/";
+const ENTAILMENT = "http://www.w3.org/ns/entailment/";
+/**
+* The `http://www.w3.org/ns/formats/` IRIs of well-known media types.
+*
+* @since 0.1.0
+* @category vocabulary
+*/
+const formatIris = {
+	"text/turtle": `${FORMATS}Turtle`,
+	"application/n-triples": `${FORMATS}N-Triples`,
+	"application/rdf+xml": `${FORMATS}RDF_XML`,
+	"application/ld+json": `${FORMATS}JSON-LD`,
+	"text/n3": `${FORMATS}N3`,
+	"application/trig": `${FORMATS}TriG`,
+	"application/n-quads": `${FORMATS}N-Quads`,
+	"application/rdf+json": `${FORMATS}RDF_JSON`,
+	"application/sparql-results+json": `${FORMATS}SPARQL_Results_JSON`,
+	"application/sparql-results+xml": `${FORMATS}SPARQL_Results_XML`,
+	"text/csv": `${FORMATS}SPARQL_Results_CSV`,
+	"text/tab-separated-values": `${FORMATS}SPARQL_Results_TSV`
+};
+const sd = (local) => namedNode(`${SD}${local}`);
+/**
+* Builds the service description as triples.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const describe = (options) => {
+	const endpoints = [options.endpoint];
+	const quads = [];
+	const add = (s, p, o) => quads.push(quad(s, p, o));
+	if (options.updateEndpoint !== void 0 && options.updateEndpoint !== options.endpoint) endpoints.push(options.updateEndpoint);
+	endpoints.forEach((endpoint) => {
+		const service = blankNode();
+		add(service, RDF_TYPE, sd("Service"));
+		add(service, sd("endpoint"), namedNode(endpoint));
+		if (endpoint === options.endpoint) {
+			add(service, sd("supportedLanguage"), sd("SPARQL10Query"));
+			add(service, sd("supportedLanguage"), sd("SPARQL11Query"));
+		}
+		if (options.updateEndpoint === endpoint) add(service, sd("supportedLanguage"), sd("SPARQL11Update"));
+		Arr.dedupe([...codecs.map((codec) => codec.format.mediaType), ...options.formats.serializers.map((s) => s.format.mediaType)]).forEach((mt) => {
+			const iri = formatIris[mt];
+			if (iri !== void 0) add(service, sd("resultFormat"), namedNode(iri));
+		});
+		options.formats.parsers.forEach((p) => {
+			const iri = formatIris[p.format.mediaType];
+			if (iri !== void 0) add(service, sd("inputFormat"), namedNode(iri));
+		});
+		if (options.unionDefaultGraph) add(service, sd("feature"), sd("UnionDefaultGraph"));
+		if (options.federation) add(service, sd("feature"), sd("BasicFederatedQuery"));
+		add(service, sd("feature"), sd("EmptyGraphs"));
+		add(service, sd("defaultEntailmentRegime"), namedNode(`${ENTAILMENT}Simple`));
+		const dataset = blankNode();
+		add(service, sd("defaultDataset"), dataset);
+		add(dataset, RDF_TYPE, sd("Dataset"));
+		const defaultGraph = blankNode();
+		add(dataset, sd("defaultGraph"), defaultGraph);
+		add(defaultGraph, RDF_TYPE, sd("Graph"));
+		options.namedGraphs.forEach((g) => {
+			const named = blankNode();
+			add(dataset, sd("namedGraph"), named);
+			add(named, RDF_TYPE, sd("NamedGraph"));
+			add(named, sd("name"), g);
+		});
+	});
+	return quads;
+};
+export { formatIris as i, ServiceDescription_exports as n, describe as r, SD as t };
+
+//# sourceMappingURL=ServiceDescription-Dq5hxeGy.mjs.map