@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Extract-Bop85jES.mjs

@@ -0,0 +1,220 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+// src/xmp/Extract.ts
+/**
+* Reading the XMP packet embedded in an image file, as XMP Specification
+* Part 3 places it: a JPEG's APP1 segment (with Extended XMP split across
+* further APP1 segments) or a PNG's `iTXt` chunk with the keyword
+* `XML:com.adobe.xmp` (stored or, read with `png`, zlib-compressed). Any
+* other format (TIFF, WebP, GIF, MP4, PDF, …) can
+* be scanned for its packet with `Packet.find`.
+*
+* @since 0.1.0
+*/
+var Extract_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_MAX_XMP_BYTES: () => DEFAULT_MAX_XMP_BYTES,
+	XmpExtractError: () => XmpExtractError,
+	jpeg: () => jpeg,
+	jpegResult: () => jpegResult,
+	png: () => png,
+	pngResult: () => pngResult
+});
+/**
+* A malformed image file.
+*
+* @since 0.1.0
+* @category errors
+*/
+var XmpExtractError = class extends Schema.TaggedError()("XmpExtractError", { message: Schema.String }) {};
+const fail = (message) => {
+	throw new XmpExtractError({ message });
+};
+const ascii = (text) => Uint8Array.from(Arr.map(Arr.fromIterable(text), (c) => c.charCodeAt(0)));
+const startsWith = (bytes, prefix) => bytes.length >= prefix.length && Arr.every(Arr.fromIterable(prefix), (b, i) => bytes[i] === b);
+const utf8 = (bytes) => new TextDecoder().decode(bytes);
+const latin1 = (bytes) => new TextDecoder("windows-1252").decode(bytes);
+const view = (bytes) => new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+const catchExtract = (f) => Result.try({
+	try: f,
+	catch: (e) => {
+		if (e instanceof XmpExtractError) return e;
+		throw e;
+	}
+});
+const STANDARD = ascii("http://ns.adobe.com/xap/1.0/\0");
+const EXTENSION = ascii("http://ns.adobe.com/xmp/extension/\0");
+const APP1 = 225;
+const isStandalone = (marker) => marker === 1 || marker === 255 || marker >= 208 && marker <= 215;
+/** The segments before the image data (SOS) or the end of the image (EOI). */
+const jpegSegments = (bytes) => {
+	const data = view(bytes);
+	return Arr.getSomes(Arr.unfold(2, (pos) => {
+		if (pos + 2 > bytes.length) return Option.none();
+		if (data.getUint8(pos) !== 255) return fail(`Expected a JPEG marker at offset ${pos}`);
+		const marker = data.getUint8(pos + 1);
+		if (marker === 217 || marker === 218) return Option.none();
+		if (isStandalone(marker)) return Option.some([Option.none(), marker === 255 ? pos + 1 : pos + 2]);
+		if (pos + 4 > bytes.length) return fail(`Truncated JPEG segment at offset ${pos}`);
+		const length = data.getUint16(pos + 2);
+		const end = pos + 2 + length;
+		if (length < 2 || end > bytes.length) return fail(`Truncated JPEG segment at offset ${pos}`);
+		return Option.some([Option.some({
+			marker,
+			data: bytes.subarray(pos + 4, end)
+		}), end]);
+	}));
+};
+const extensionChunk = (payload) => {
+	const header = EXTENSION.length + 40;
+	if (payload.length < header) return fail("Truncated Extended XMP segment");
+	const data = view(payload);
+	return {
+		guid: latin1(payload.subarray(EXTENSION.length, EXTENSION.length + 32)),
+		length: data.getUint32(EXTENSION.length + 32),
+		offset: data.getUint32(EXTENSION.length + 36),
+		data: payload.subarray(header)
+	};
+};
+/** Reassembles the Extended XMP whose GUID the standard packet names. */
+const extended = (standard, chunks) => Option.map(Arr.findFirst(chunks, (c) => standard.includes(c.guid)), ({ guid, length }) => {
+	const whole = new Uint8Array(length);
+	Arr.filter(chunks, (c) => c.guid === guid).forEach((c) => {
+		if (c.offset + c.data.length > length) fail("Extended XMP chunk out of bounds");
+		whole.set(c.data, c.offset);
+	});
+	return utf8(whole);
+});
+/**
+* Reads the XMP of a JPEG file, returning a `Result`: `None` when the file
+* has no XMP.
+*
+* @since 0.1.0
+* @category extraction
+*/
+const jpegResult = (bytes) => catchExtract(() => {
+	if (bytes[0] !== 255 || bytes[1] !== 216) return fail("Not a JPEG file");
+	const app1 = Arr.map(Arr.filter(jpegSegments(bytes), (s) => s.marker === APP1), (s) => s.data);
+	const chunks = Arr.map(Arr.filter(app1, (d) => startsWith(d, EXTENSION)), extensionChunk);
+	return Option.map(Arr.findFirst(app1, (d) => startsWith(d, STANDARD)), (d) => {
+		const standard = utf8(d.subarray(STANDARD.length));
+		return {
+			standard,
+			extended: extended(standard, chunks)
+		};
+	});
+});
+/**
+* Reads the XMP of a JPEG file: `None` when the file has no XMP.
+*
+* @since 0.1.0
+* @category extraction
+*/
+const jpeg = (bytes) => Effect.suspend(() => Effect.fromResult(jpegResult(bytes)));
+const PNG_SIGNATURE = Uint8Array.of(137, 80, 78, 71, 13, 10, 26, 10);
+const XMP_KEYWORD = "XML:com.adobe.xmp";
+const pngChunks = (bytes) => {
+	const data = view(bytes);
+	return Arr.unfold(PNG_SIGNATURE.length, (pos) => {
+		if (pos >= bytes.length) return Option.none();
+		if (pos + 12 > bytes.length) return fail(`Truncated PNG chunk at offset ${pos}`);
+		const length = data.getUint32(pos);
+		const type = latin1(bytes.subarray(pos + 4, pos + 8));
+		const end = pos + 12 + length;
+		if (end > bytes.length) return fail(`Truncated PNG chunk at offset ${pos}`);
+		if (type === "IEND") return Option.none();
+		return Option.some([{
+			type,
+			data: bytes.subarray(pos + 8, pos + 8 + length)
+		}, end]);
+	});
+};
+/** The XMP of an `iTXt` chunk, when its keyword is XMP's. */
+const xmpChunk = (chunk) => {
+	const keywordEnd = chunk.indexOf(0);
+	if (keywordEnd < 0 || latin1(chunk.subarray(0, keywordEnd)) !== XMP_KEYWORD) return Option.none();
+	const compressed = chunk[keywordEnd + 1] !== 0;
+	if (compressed && chunk[keywordEnd + 2] !== 0) return fail("Unknown iTXt compression method");
+	const languageEnd = chunk.indexOf(0, keywordEnd + 3);
+	const translatedEnd = languageEnd < 0 ? -1 : chunk.indexOf(0, languageEnd + 1);
+	if (translatedEnd < 0) return fail("Malformed iTXt chunk");
+	return Option.some({
+		compressed,
+		text: chunk.subarray(translatedEnd + 1)
+	});
+};
+const pngXmpChunk = (bytes) => {
+	if (!startsWith(bytes, PNG_SIGNATURE)) return fail("Not a PNG file");
+	return Option.firstSomeOf(Arr.map(Arr.filter(pngChunks(bytes), (c) => c.type === "iTXt"), (c) => xmpChunk(c.data)));
+};
+/**
+* The most bytes `Extract.png` inflates a compressed XMP chunk to by
+* default: 4 MiB, far above any real packet, so a small deflate bomb fails
+* instead of exhausting memory.
+*
+* @since 0.1.0
+* @category constants
+*/
+const DEFAULT_MAX_XMP_BYTES = 4194304;
+const concatChunks = (chunks, total) => {
+	const out = new Uint8Array(total);
+	Arr.reduce(chunks, 0, (offset, chunk) => {
+		out.set(chunk, offset);
+		return offset + chunk.length;
+	});
+	return out;
+};
+/**
+* Reads a stream to its end, failing (and cancelling it) as soon as the
+* running total passes `max`, so nothing past the cap is buffered.
+*/
+const readCapped = (reader, max, chunks, total) => reader.read().then((result) => {
+	if (result.done) return concatChunks(chunks, total);
+	const next = total + result.value.length;
+	if (next > max) {
+		reader.cancel();
+		return fail(`Compressed XMP iTXt chunk inflates to more than ${max} bytes`);
+	}
+	chunks.push(result.value);
+	return readCapped(reader, max, chunks, next);
+});
+/** Inflates zlib data with the platform's `DecompressionStream`, up to `max` bytes. */
+const inflate = (data, max) => Effect.tryPromise({
+	try: () => {
+		const source = new ReadableStream({ start: (controller) => {
+			controller.enqueue(data.slice());
+			controller.close();
+		} });
+		return readCapped(source.pipeThrough(new DecompressionStream("deflate")).getReader(), max, [], 0);
+	},
+	catch: (e) => e instanceof XmpExtractError ? e : new XmpExtractError({ message: "Malformed compressed iTXt chunk" })
+});
+/**
+* Reads the XMP packet of a PNG file, returning a `Result`: `None` when the
+* file has no XMP. Decompression is asynchronous, so a compressed `iTXt`
+* chunk fails here; `png` inflates it. (The XMP specification writes the
+* chunk uncompressed, so a scanner can find the packet.)
+*
+* @since 0.1.0
+* @category extraction
+*/
+const pngResult = (bytes) => catchExtract(() => Option.map(pngXmpChunk(bytes), (chunk) => chunk.compressed ? fail("A compressed XMP iTXt chunk needs Extract.png, which inflates it") : utf8(chunk.text)));
+/**
+* Reads the XMP packet of a PNG file: `None` when the file has no XMP. A
+* zlib-compressed `iTXt` chunk is inflated with the platform's
+* `DecompressionStream` (Node, browsers and Workers all provide it), and
+* fails once it inflates past `maxXmpBytes` (default `DEFAULT_MAX_XMP_BYTES`).
+*
+* @since 0.1.0
+* @category extraction
+*/
+const png = (bytes, options) => Effect.flatMap(Effect.suspend(() => Effect.fromResult(catchExtract(() => pngXmpChunk(bytes)))), Option.match({
+	onNone: () => Effect.succeed(Option.none()),
+	onSome: (chunk) => chunk.compressed ? Effect.map(inflate(chunk.text, options?.maxXmpBytes ?? 4194304), (text) => Option.some(utf8(text))) : Effect.succeed(Option.some(utf8(chunk.text)))
+}));
+export { jpegResult as a, jpeg as i, Extract_exports as n, png as o, XmpExtractError as r, pngResult as s, DEFAULT_MAX_XMP_BYTES as t };
+
+//# sourceMappingURL=Extract-Bop85jES.mjs.map

package/dist/Extract-Bop85jES.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Extract-Bop85jES.mjs","names":[],"sources":["../src/xmp/Extract.ts"],"sourcesContent":["/**\n * Reading the XMP packet embedded in an image file, as XMP Specification\n * Part 3 places it: a JPEG's APP1 segment (with Extended XMP split across\n * further APP1 segments) or a PNG's `iTXt` chunk with the keyword\n * `XML:com.adobe.xmp` (stored or, read with `png`, zlib-compressed). Any\n * other format (TIFF, WebP, GIF, MP4, PDF, …) can\n * be scanned for its packet with `Packet.find`.\n *\n * @since 0.1.0\n */\nimport * as Arr from 'effect/Array';\nimport * as Effect from 'effect/Effect';\nimport * as Option from 'effect/Option';\nimport * as Result from 'effect/Result';\nimport * as Schema from 'effect/Schema';\n\n/**\n * A malformed image file.\n *\n * @since 0.1.0\n * @category errors\n */\nexport class XmpExtractError extends Schema.TaggedError<XmpExtractError>()('XmpExtractError', {\n  message: Schema.String,\n}) {}\n\n/**\n * The XMP of a JPEG file: the standard packet and, when the packet does not\n * fit one segment, the Extended XMP document its `xmpNote:HasExtendedXMP`\n * names.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface JpegXmp {\n  readonly standard: string;\n  readonly extended: Option.Option<string>;\n}\n\nconst fail = (message: string): never => {\n  throw new XmpExtractError({ message });\n};\n\nconst ascii = (text: string): Uint8Array =>\n  Uint8Array.from(Arr.map(Arr.fromIterable(text), (c) => c.charCodeAt(0)));\n\nconst startsWith = (bytes: Uint8Array, prefix: Uint8Array): boolean =>\n  bytes.length >= prefix.length && Arr.every(Arr.fromIterable(prefix), (b, i) => bytes[i] === b);\n\nconst utf8 = (bytes: Uint8Array): string => new TextDecoder().decode(bytes);\nconst latin1 = (bytes: Uint8Array): string => new TextDecoder('windows-1252').decode(bytes);\n\nconst view = (bytes: Uint8Array) => new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n\nconst catchExtract = <A>(f: () => A): Result.Result<A, XmpExtractError> =>\n  Result.try({\n    try: f,\n    catch: (e) => {\n      if (e instanceof XmpExtractError) return e;\n      throw e;\n    },\n  });\n\n// -----------------------------------------------------------------------------\n// JPEG\n// -----------------------------------------------------------------------------\n\nconst STANDARD = ascii('http://ns.adobe.com/xap/1.0/\\0');\nconst EXTENSION = ascii('http://ns.adobe.com/xmp/extension/\\0');\nconst APP1 = 0xe1;\n\ninterface Segment {\n  readonly marker: number;\n  readonly data: Uint8Array;\n}\n\nconst isStandalone = (marker: number) =>\n  marker === 0x01 || marker === 0xff || (marker >= 0xd0 && marker <= 0xd7);\n\n/** The segments before the image data (SOS) or the end of the image (EOI). */\nconst jpegSegments = (bytes: Uint8Array): ReadonlyArray<Segment> => {\n  const data = view(bytes);\n  return Arr.getSomes(\n    Arr.unfold(2, (pos): Option.Option<readonly [Option.Option<Segment>, number]> => {\n      if (pos + 2 > bytes.length) return Option.none();\n      if (data.getUint8(pos) !== 0xff) return fail(`Expected a JPEG marker at offset ${pos}`);\n      const marker = data.getUint8(pos + 1);\n      if (marker === 0xd9 || marker === 0xda) return Option.none();\n      // A fill byte (0xFF) or a marker without a length.\n      if (isStandalone(marker))\n        return Option.some([Option.none(), marker === 0xff ? pos + 1 : pos + 2]);\n      if (pos + 4 > bytes.length) return fail(`Truncated JPEG segment at offset ${pos}`);\n      const length = data.getUint16(pos + 2);\n      const end = pos + 2 + length;\n      if (length < 2 || end > bytes.length) return fail(`Truncated JPEG segment at offset ${pos}`);\n      return Option.some([Option.some({ marker, data: bytes.subarray(pos + 4, end) }), end]);\n    }),\n  );\n};\n\ninterface Chunk {\n  readonly guid: string;\n  readonly length: number;\n  readonly offset: number;\n  readonly data: Uint8Array;\n}\n\nconst extensionChunk = (payload: Uint8Array): Chunk => {\n  const header = EXTENSION.length + 40;\n  if (payload.length < header) return fail('Truncated Extended XMP segment');\n  const data = view(payload);\n  return {\n    guid: latin1(payload.subarray(EXTENSION.length, EXTENSION.length + 32)),\n    length: data.getUint32(EXTENSION.length + 32),\n    offset: data.getUint32(EXTENSION.length + 36),\n    data: payload.subarray(header),\n  };\n};\n\n/** Reassembles the Extended XMP whose GUID the standard packet names. */\nconst extended = (standard: string, chunks: ReadonlyArray<Chunk>): Option.Option<string> =>\n  Option.map(\n    Arr.findFirst(chunks, (c) => standard.includes(c.guid)),\n    ({ guid, length }) => {\n      const whole = new Uint8Array(length);\n      Arr.filter(chunks, (c) => c.guid === guid).forEach((c) => {\n        if (c.offset + c.data.length > length) fail('Extended XMP chunk out of bounds');\n        whole.set(c.data, c.offset);\n      });\n      return utf8(whole);\n    },\n  );\n\n/**\n * Reads the XMP of a JPEG file, returning a `Result`: `None` when the file\n * has no XMP.\n *\n * @since 0.1.0\n * @category extraction\n */\nexport const jpegResult = (\n  bytes: Uint8Array,\n): Result.Result<Option.Option<JpegXmp>, XmpExtractError> =>\n  catchExtract(() => {\n    if (bytes[0] !== 0xff || bytes[1] !== 0xd8) return fail('Not a JPEG file');\n    const app1 = Arr.map(\n      Arr.filter(jpegSegments(bytes), (s) => s.marker === APP1),\n      (s) => s.data,\n    );\n    const chunks = Arr.map(\n      Arr.filter(app1, (d) => startsWith(d, EXTENSION)),\n      extensionChunk,\n    );\n    return Option.map(\n      Arr.findFirst(app1, (d) => startsWith(d, STANDARD)),\n      (d) => {\n        const standard = utf8(d.subarray(STANDARD.length));\n        return { standard, extended: extended(standard, chunks) };\n      },\n    );\n  });\n\n/**\n * Reads the XMP of a JPEG file: `None` when the file has no XMP.\n *\n * @since 0.1.0\n * @category extraction\n */\nexport const jpeg = (bytes: Uint8Array): Effect.Effect<Option.Option<JpegXmp>, XmpExtractError> =>\n  Effect.suspend(() => Effect.fromResult(jpegResult(bytes)));\n\n// -----------------------------------------------------------------------------\n// PNG\n// -----------------------------------------------------------------------------\n\nconst PNG_SIGNATURE = Uint8Array.of(0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a);\nconst XMP_KEYWORD = 'XML:com.adobe.xmp';\n\ninterface PngChunk {\n  readonly type: string;\n  readonly data: Uint8Array;\n}\n\nconst pngChunks = (bytes: Uint8Array): ReadonlyArray<PngChunk> => {\n  const data = view(bytes);\n  return Arr.unfold(PNG_SIGNATURE.length, (pos): Option.Option<readonly [PngChunk, number]> => {\n    if (pos >= bytes.length) return Option.none();\n    if (pos + 12 > bytes.length) return fail(`Truncated PNG chunk at offset ${pos}`);\n    const length = data.getUint32(pos);\n    const type = latin1(bytes.subarray(pos + 4, pos + 8));\n    const end = pos + 12 + length;\n    if (end > bytes.length) return fail(`Truncated PNG chunk at offset ${pos}`);\n    if (type === 'IEND') return Option.none();\n    return Option.some([{ type, data: bytes.subarray(pos + 8, pos + 8 + length) }, end]);\n  });\n};\n\n/** The text of an XMP `iTXt` chunk: stored, or zlib-compressed. */\ninterface XmpChunk {\n  readonly compressed: boolean;\n  readonly text: Uint8Array;\n}\n\n/** The XMP of an `iTXt` chunk, when its keyword is XMP's. */\nconst xmpChunk = (chunk: Uint8Array): Option.Option<XmpChunk> => {\n  const keywordEnd = chunk.indexOf(0);\n  if (keywordEnd < 0 || latin1(chunk.subarray(0, keywordEnd)) !== XMP_KEYWORD) {\n    return Option.none();\n  }\n  const compressed = chunk[keywordEnd + 1] !== 0;\n  // Compression method 0 (zlib) is the only one PNG defines.\n  if (compressed && chunk[keywordEnd + 2] !== 0) return fail('Unknown iTXt compression method');\n  const languageEnd = chunk.indexOf(0, keywordEnd + 3);\n  const translatedEnd = languageEnd < 0 ? -1 : chunk.indexOf(0, languageEnd + 1);\n  if (translatedEnd < 0) return fail('Malformed iTXt chunk');\n  return Option.some({ compressed, text: chunk.subarray(translatedEnd + 1) });\n};\n\nconst pngXmpChunk = (bytes: Uint8Array): Option.Option<XmpChunk> => {\n  if (!startsWith(bytes, PNG_SIGNATURE)) return fail('Not a PNG file');\n  return Option.firstSomeOf(\n    Arr.map(\n      Arr.filter(pngChunks(bytes), (c) => c.type === 'iTXt'),\n      (c) => xmpChunk(c.data),\n    ),\n  );\n};\n\n/**\n * The most bytes `Extract.png` inflates a compressed XMP chunk to by\n * default: 4 MiB, far above any real packet, so a small deflate bomb fails\n * instead of exhausting memory.\n *\n * @since 0.1.0\n * @category constants\n */\nexport const DEFAULT_MAX_XMP_BYTES = 4 * 1024 * 1024;\n\n/**\n * Options for `Extract.png`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface PngOptions {\n  /**\n   * The most bytes a compressed `iTXt` chunk may inflate to; past it the\n   * read fails. Defaults to `DEFAULT_MAX_XMP_BYTES`.\n   */\n  readonly maxXmpBytes?: number | undefined;\n}\n\nconst concatChunks = (chunks: ReadonlyArray<Uint8Array>, total: number): Uint8Array => {\n  const out = new Uint8Array(total);\n  Arr.reduce(chunks, 0, (offset, chunk) => {\n    out.set(chunk, offset);\n    return offset + chunk.length;\n  });\n  return out;\n};\n\n/**\n * Reads a stream to its end, failing (and cancelling it) as soon as the\n * running total passes `max`, so nothing past the cap is buffered.\n */\nconst readCapped = (\n  reader: ReadableStreamDefaultReader<Uint8Array>,\n  max: number,\n  chunks: Array<Uint8Array>,\n  total: number,\n): Promise<Uint8Array> =>\n  reader.read().then((result) => {\n    if (result.done) return concatChunks(chunks, total);\n    const next = total + result.value.length;\n    if (next > max) {\n      void reader.cancel();\n      return fail(`Compressed XMP iTXt chunk inflates to more than ${max} bytes`);\n    }\n    chunks.push(result.value);\n    return readCapped(reader, max, chunks, next);\n  });\n\n/** Inflates zlib data with the platform's `DecompressionStream`, up to `max` bytes. */\nconst inflate = (data: Uint8Array, max: number): Effect.Effect<Uint8Array, XmpExtractError> =>\n  Effect.tryPromise({\n    try: () => {\n      const source = new ReadableStream<BufferSource>({\n        start: (controller) => {\n          // A copy: `BufferSource` excludes a view over a `SharedArrayBuffer`.\n          controller.enqueue(data.slice());\n          controller.close();\n        },\n      });\n      return readCapped(\n        source.pipeThrough(new DecompressionStream('deflate')).getReader(),\n        max,\n        [],\n        0,\n      );\n    },\n    catch: (e) =>\n      e instanceof XmpExtractError\n        ? e\n        : new XmpExtractError({ message: 'Malformed compressed iTXt chunk' }),\n  });\n\n/**\n * Reads the XMP packet of a PNG file, returning a `Result`: `None` when the\n * file has no XMP. Decompression is asynchronous, so a compressed `iTXt`\n * chunk fails here; `png` inflates it. (The XMP specification writes the\n * chunk uncompressed, so a scanner can find the packet.)\n *\n * @since 0.1.0\n * @category extraction\n */\nexport const pngResult = (\n  bytes: Uint8Array,\n): Result.Result<Option.Option<string>, XmpExtractError> =>\n  catchExtract(() =>\n    Option.map(pngXmpChunk(bytes), (chunk) =>\n      chunk.compressed\n        ? fail('A compressed XMP iTXt chunk needs Extract.png, which inflates it')\n        : utf8(chunk.text),\n    ),\n  );\n\n/**\n * Reads the XMP packet of a PNG file: `None` when the file has no XMP. A\n * zlib-compressed `iTXt` chunk is inflated with the platform's\n * `DecompressionStream` (Node, browsers and Workers all provide it), and\n * fails once it inflates past `maxXmpBytes` (default `DEFAULT_MAX_XMP_BYTES`).\n *\n * @since 0.1.0\n * @category extraction\n */\nexport const png = (\n  bytes: Uint8Array,\n  options?: PngOptions,\n): Effect.Effect<Option.Option<string>, XmpExtractError> =>\n  Effect.flatMap(\n    Effect.suspend(() => Effect.fromResult(catchExtract(() => pngXmpChunk(bytes)))),\n    Option.match({\n      onNone: () => Effect.succeed(Option.none()),\n      onSome: (chunk) =>\n        chunk.compressed\n          ? Effect.map(inflate(chunk.text, options?.maxXmpBytes ?? DEFAULT_MAX_XMP_BYTES), (text) =>\n              Option.some(utf8(text)),\n            )\n          : Effect.succeed(Option.some(utf8(chunk.text))),\n    }),\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,IAAa,kBAAb,cAAqC,OAAO,YAA6B,CAAC,CAAC,mBAAmB,EAC5F,SAAS,OAAO,OAClB,CAAC,CAAC,CAAC,CAAC;AAeJ,MAAM,QAAQ,YAA2B;CACvC,MAAM,IAAI,gBAAgB,EAAE,QAAQ,CAAC;AACvC;AAEA,MAAM,SAAS,SACb,WAAW,KAAK,IAAI,IAAI,IAAI,aAAa,IAAI,IAAI,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;AAEzE,MAAM,cAAc,OAAmB,WACrC,MAAM,UAAU,OAAO,UAAU,IAAI,MAAM,IAAI,aAAa,MAAM,IAAI,GAAG,MAAM,MAAM,OAAO,CAAC;AAE/F,MAAM,QAAQ,UAA8B,IAAI,YAAY,CAAC,CAAC,OAAO,KAAK;AAC1E,MAAM,UAAU,UAA8B,IAAI,YAAY,cAAc,CAAC,CAAC,OAAO,KAAK;AAE1F,MAAM,QAAQ,UAAsB,IAAI,SAAS,MAAM,QAAQ,MAAM,YAAY,MAAM,UAAU;AAEjG,MAAM,gBAAmB,MACvB,OAAO,IAAI;CACT,KAAK;CACL,QAAQ,MAAM;EACZ,IAAI,aAAa,iBAAiB,OAAO;EACzC,MAAM;CACR;AACF,CAAC;AAMH,MAAM,WAAW,MAAM,gCAAgC;AACvD,MAAM,YAAY,MAAM,sCAAsC;AAC9D,MAAM,OAAO;AAOb,MAAM,gBAAgB,WACpB,WAAW,KAAQ,WAAW,OAAS,UAAU,OAAQ,UAAU;;AAGrE,MAAM,gBAAgB,UAA8C;CAClE,MAAM,OAAO,KAAK,KAAK;CACvB,OAAO,IAAI,SACT,IAAI,OAAO,IAAI,QAAkE;EAC/E,IAAI,MAAM,IAAI,MAAM,QAAQ,OAAO,OAAO,KAAK;EAC/C,IAAI,KAAK,SAAS,GAAG,MAAM,KAAM,OAAO,KAAK,oCAAoC,KAAK;EACtF,MAAM,SAAS,KAAK,SAAS,MAAM,CAAC;EACpC,IAAI,WAAW,OAAQ,WAAW,KAAM,OAAO,OAAO,KAAK;EAE3D,IAAI,aAAa,MAAM,GACrB,OAAO,OAAO,KAAK,CAAC,OAAO,KAAK,GAAG,WAAW,MAAO,MAAM,IAAI,MAAM,CAAC,CAAC;EACzE,IAAI,MAAM,IAAI,MAAM,QAAQ,OAAO,KAAK,oCAAoC,KAAK;EACjF,MAAM,SAAS,KAAK,UAAU,MAAM,CAAC;EACrC,MAAM,MAAM,MAAM,IAAI;EACtB,IAAI,SAAS,KAAK,MAAM,MAAM,QAAQ,OAAO,KAAK,oCAAoC,KAAK;EAC3F,OAAO,OAAO,KAAK,CAAC,OAAO,KAAK;GAAE;GAAQ,MAAM,MAAM,SAAS,MAAM,GAAG,GAAG;EAAE,CAAC,GAAG,GAAG,CAAC;CACvF,CAAC,CACH;AACF;AASA,MAAM,kBAAkB,YAA+B;CACrD,MAAM,SAAS,UAAU,SAAS;CAClC,IAAI,QAAQ,SAAS,QAAQ,OAAO,KAAK,gCAAgC;CACzE,MAAM,OAAO,KAAK,OAAO;CACzB,OAAO;EACL,MAAM,OAAO,QAAQ,SAAS,UAAU,QAAQ,UAAU,SAAS,EAAE,CAAC;EACtE,QAAQ,KAAK,UAAU,UAAU,SAAS,EAAE;EAC5C,QAAQ,KAAK,UAAU,UAAU,SAAS,EAAE;EAC5C,MAAM,QAAQ,SAAS,MAAM;CAC/B;AACF;;AAGA,MAAM,YAAY,UAAkB,WAClC,OAAO,IACL,IAAI,UAAU,SAAS,MAAM,SAAS,SAAS,EAAE,IAAI,CAAC,IACrD,EAAE,MAAM,aAAa;CACpB,MAAM,QAAQ,IAAI,WAAW,MAAM;CACnC,IAAI,OAAO,SAAS,MAAM,EAAE,SAAS,IAAI,CAAC,CAAC,SAAS,MAAM;EACxD,IAAI,EAAE,SAAS,EAAE,KAAK,SAAS,QAAQ,KAAK,kCAAkC;EAC9E,MAAM,IAAI,EAAE,MAAM,EAAE,MAAM;CAC5B,CAAC;CACD,OAAO,KAAK,KAAK;AACnB,CACF;;;;;;;;AASF,MAAa,cACX,UAEA,mBAAmB;CACjB,IAAI,MAAM,OAAO,OAAQ,MAAM,OAAO,KAAM,OAAO,KAAK,iBAAiB;CACzE,MAAM,OAAO,IAAI,IACf,IAAI,OAAO,aAAa,KAAK,IAAI,MAAM,EAAE,WAAW,IAAI,IACvD,MAAM,EAAE,IACX;CACA,MAAM,SAAS,IAAI,IACjB,IAAI,OAAO,OAAO,MAAM,WAAW,GAAG,SAAS,CAAC,GAChD,cACF;CACA,OAAO,OAAO,IACZ,IAAI,UAAU,OAAO,MAAM,WAAW,GAAG,QAAQ,CAAC,IACjD,MAAM;EACL,MAAM,WAAW,KAAK,EAAE,SAAS,SAAS,MAAM,CAAC;EACjD,OAAO;GAAE;GAAU,UAAU,SAAS,UAAU,MAAM;EAAE;CAC1D,CACF;AACF,CAAC;;;;;;;AAQH,MAAa,QAAQ,UACnB,OAAO,cAAc,OAAO,WAAW,WAAW,KAAK,CAAC,CAAC;AAM3D,MAAM,gBAAgB,WAAW,GAAG,KAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,EAAI;AAClF,MAAM,cAAc;AAOpB,MAAM,aAAa,UAA+C;CAChE,MAAM,OAAO,KAAK,KAAK;CACvB,OAAO,IAAI,OAAO,cAAc,SAAS,QAAoD;EAC3F,IAAI,OAAO,MAAM,QAAQ,OAAO,OAAO,KAAK;EAC5C,IAAI,MAAM,KAAK,MAAM,QAAQ,OAAO,KAAK,iCAAiC,KAAK;EAC/E,MAAM,SAAS,KAAK,UAAU,GAAG;EACjC,MAAM,OAAO,OAAO,MAAM,SAAS,MAAM,GAAG,MAAM,CAAC,CAAC;EACpD,MAAM,MAAM,MAAM,KAAK;EACvB,IAAI,MAAM,MAAM,QAAQ,OAAO,KAAK,iCAAiC,KAAK;EAC1E,IAAI,SAAS,QAAQ,OAAO,OAAO,KAAK;EACxC,OAAO,OAAO,KAAK,CAAC;GAAE;GAAM,MAAM,MAAM,SAAS,MAAM,GAAG,MAAM,IAAI,MAAM;EAAE,GAAG,GAAG,CAAC;CACrF,CAAC;AACH;;AASA,MAAM,YAAY,UAA+C;CAC/D,MAAM,aAAa,MAAM,QAAQ,CAAC;CAClC,IAAI,aAAa,KAAK,OAAO,MAAM,SAAS,GAAG,UAAU,CAAC,MAAM,aAC9D,OAAO,OAAO,KAAK;CAErB,MAAM,aAAa,MAAM,aAAa,OAAO;CAE7C,IAAI,cAAc,MAAM,aAAa,OAAO,GAAG,OAAO,KAAK,iCAAiC;CAC5F,MAAM,cAAc,MAAM,QAAQ,GAAG,aAAa,CAAC;CACnD,MAAM,gBAAgB,cAAc,IAAI,KAAK,MAAM,QAAQ,GAAG,cAAc,CAAC;CAC7E,IAAI,gBAAgB,GAAG,OAAO,KAAK,sBAAsB;CACzD,OAAO,OAAO,KAAK;EAAE;EAAY,MAAM,MAAM,SAAS,gBAAgB,CAAC;CAAE,CAAC;AAC5E;AAEA,MAAM,eAAe,UAA+C;CAClE,IAAI,CAAC,WAAW,OAAO,aAAa,GAAG,OAAO,KAAK,gBAAgB;CACnE,OAAO,OAAO,YACZ,IAAI,IACF,IAAI,OAAO,UAAU,KAAK,IAAI,MAAM,EAAE,SAAS,MAAM,IACpD,MAAM,SAAS,EAAE,IAAI,CACxB,CACF;AACF;;;;;;;;;AAUA,MAAa,wBAAwB;AAgBrC,MAAM,gBAAgB,QAAmC,UAA8B;CACrF,MAAM,MAAM,IAAI,WAAW,KAAK;CAChC,IAAI,OAAO,QAAQ,IAAI,QAAQ,UAAU;EACvC,IAAI,IAAI,OAAO,MAAM;EACrB,OAAO,SAAS,MAAM;CACxB,CAAC;CACD,OAAO;AACT;;;;;AAMA,MAAM,cACJ,QACA,KACA,QACA,UAEA,OAAO,KAAK,CAAC,CAAC,MAAM,WAAW;CAC7B,IAAI,OAAO,MAAM,OAAO,aAAa,QAAQ,KAAK;CAClD,MAAM,OAAO,QAAQ,OAAO,MAAM;CAClC,IAAI,OAAO,KAAK;EACd,OAAY,OAAO;EACnB,OAAO,KAAK,mDAAmD,IAAI,OAAO;CAC5E;CACA,OAAO,KAAK,OAAO,KAAK;CACxB,OAAO,WAAW,QAAQ,KAAK,QAAQ,IAAI;AAC7C,CAAC;;AAGH,MAAM,WAAW,MAAkB,QACjC,OAAO,WAAW;CAChB,WAAW;EACT,MAAM,SAAS,IAAI,eAA6B,EAC9C,QAAQ,eAAe;GAErB,WAAW,QAAQ,KAAK,MAAM,CAAC;GAC/B,WAAW,MAAM;EACnB,EACF,CAAC;EACD,OAAO,WACL,OAAO,YAAY,IAAI,oBAAoB,SAAS,CAAC,CAAC,CAAC,UAAU,GACjE,KACA,CAAC,GACD,CACF;CACF;CACA,QAAQ,MACN,aAAa,kBACT,IACA,IAAI,gBAAgB,EAAE,SAAS,kCAAkC,CAAC;AAC1E,CAAC;;;;;;;;;;AAWH,MAAa,aACX,UAEA,mBACE,OAAO,IAAI,YAAY,KAAK,IAAI,UAC9B,MAAM,aACF,KAAK,kEAAkE,IACvE,KAAK,MAAM,IAAI,CACrB,CACF;;;;;;;;;;AAWF,MAAa,OACX,OACA,YAEA,OAAO,QACL,OAAO,cAAc,OAAO,WAAW,mBAAmB,YAAY,KAAK,CAAC,CAAC,CAAC,GAC9E,OAAO,MAAM;CACX,cAAc,OAAO,QAAQ,OAAO,KAAK,CAAC;CAC1C,SAAS,UACP,MAAM,aACF,OAAO,IAAI,QAAQ,MAAM,MAAM,SAAS,eAAA,OAAoC,IAAI,SAC9E,OAAO,KAAK,KAAK,IAAI,CAAC,CACxB,IACA,OAAO,QAAQ,OAAO,KAAK,KAAK,MAAM,IAAI,CAAC,CAAC;AACpD,CAAC,CACH"}

package/dist/Extract-C_pCvuTC.d.mts

@@ -0,0 +1,88 @@
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+declare namespace Extract_d_exports {
+  export { DEFAULT_MAX_XMP_BYTES, JpegXmp, PngOptions, XmpExtractError, jpeg, jpegResult, png, pngResult };
+}
+declare const XmpExtractError_base: Schema.Class<XmpExtractError, Schema.TaggedStruct<"XmpExtractError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A malformed image file.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+declare class XmpExtractError extends XmpExtractError_base {}
+/**
+ * The XMP of a JPEG file: the standard packet and, when the packet does not
+ * fit one segment, the Extended XMP document its `xmpNote:HasExtendedXMP`
+ * names.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface JpegXmp {
+  readonly standard: string;
+  readonly extended: Option.Option<string>;
+}
+/**
+ * Reads the XMP of a JPEG file, returning a `Result`: `None` when the file
+ * has no XMP.
+ *
+ * @since 0.1.0
+ * @category extraction
+ */
+declare const jpegResult: (bytes: Uint8Array) => Result.Result<Option.Option<JpegXmp>, XmpExtractError>;
+/**
+ * Reads the XMP of a JPEG file: `None` when the file has no XMP.
+ *
+ * @since 0.1.0
+ * @category extraction
+ */
+declare const jpeg: (bytes: Uint8Array) => Effect.Effect<Option.Option<JpegXmp>, XmpExtractError>;
+/**
+ * The most bytes `Extract.png` inflates a compressed XMP chunk to by
+ * default: 4 MiB, far above any real packet, so a small deflate bomb fails
+ * instead of exhausting memory.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+declare const DEFAULT_MAX_XMP_BYTES: number;
+/**
+ * Options for `Extract.png`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface PngOptions {
+  /**
+   * The most bytes a compressed `iTXt` chunk may inflate to; past it the
+   * read fails. Defaults to `DEFAULT_MAX_XMP_BYTES`.
+   */
+  readonly maxXmpBytes?: number | undefined;
+}
+/**
+ * Reads the XMP packet of a PNG file, returning a `Result`: `None` when the
+ * file has no XMP. Decompression is asynchronous, so a compressed `iTXt`
+ * chunk fails here; `png` inflates it. (The XMP specification writes the
+ * chunk uncompressed, so a scanner can find the packet.)
+ *
+ * @since 0.1.0
+ * @category extraction
+ */
+declare const pngResult: (bytes: Uint8Array) => Result.Result<Option.Option<string>, XmpExtractError>;
+/**
+ * Reads the XMP packet of a PNG file: `None` when the file has no XMP. A
+ * zlib-compressed `iTXt` chunk is inflated with the platform's
+ * `DecompressionStream` (Node, browsers and Workers all provide it), and
+ * fails once it inflates past `maxXmpBytes` (default `DEFAULT_MAX_XMP_BYTES`).
+ *
+ * @since 0.1.0
+ * @category extraction
+ */
+declare const png: (bytes: Uint8Array, options?: PngOptions) => Effect.Effect<Option.Option<string>, XmpExtractError>;
+export { XmpExtractError as a, png as c, PngOptions as i, pngResult as l, Extract_d_exports as n, jpeg as o, JpegXmp as r, jpegResult as s, DEFAULT_MAX_XMP_BYTES as t };
+//# sourceMappingURL=Extract-C_pCvuTC.d.mts.map

package/dist/Federation-BcNrozc1.d.mts

@@ -0,0 +1,52 @@
+import { a as QuadStore } from "./Store-D0jmVfb3.mjs";
+import { a as ServiceHandler, o as SparqlEngine, r as Loader, t as EngineOptions } from "./Engine-CYPB3g4h.mjs";
+import { t as Config } from "./SparqlClient-UPc88SHy.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as HttpClient from "effect/http/HttpClient";
+declare namespace Federation_d_exports {
+  export { RemoteConfig, layerEngine, loader, serviceHandler, serviceQuery };
+}
+/**
+ * Client settings used for remote endpoints (everything but the endpoint
+ * URLs).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type RemoteConfig = Omit<Config, 'endpoint' | 'updateEndpoint' | 'graphStoreEndpoint'>;
+/**
+ * The query sent to a remote endpoint for a `SERVICE` pattern:
+ * `SELECT * WHERE { … }` with the prefixes of the original query.
+ *
+ * @since 0.1.0
+ * @category federation
+ */
+declare const serviceQuery: (service: Parameters<ServiceHandler>[1]) => string;
+/**
+ * Builds a `SERVICE` handler that sends each remote pattern to its endpoint
+ * with the `HttpClient` from the context. Clients are cached per endpoint.
+ *
+ * @since 0.1.0
+ * @category federation
+ */
+declare const serviceHandler: (config?: RemoteConfig) => Effect.Effect<ServiceHandler, never, HttpClient.HttpClient>;
+/**
+ * Builds a `LOAD` handler that fetches documents over HTTP and parses them
+ * with the `Serialization.Formats` service (or the default formats), by
+ * media type or, failing that, by file extension.
+ *
+ * @since 0.1.0
+ * @category federation
+ */
+declare const loader: (config?: Pick<RemoteConfig, "headers" | "timeout">) => Effect.Effect<Loader, never, HttpClient.HttpClient>;
+/**
+ * A `SparqlEngine` layer whose `SERVICE` patterns are evaluated remotely and
+ * whose `LOAD` fetches documents over HTTP.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const layerEngine: (options?: EngineOptions, config?: RemoteConfig) => Layer.Layer<SparqlEngine, never, QuadStore | HttpClient.HttpClient>;
+export { serviceHandler as a, loader as i, RemoteConfig as n, serviceQuery as o, layerEngine as r, Federation_d_exports as t };
+//# sourceMappingURL=Federation-BcNrozc1.d.mts.map

package/dist/Federation-CHScBkaK.mjs

@@ -0,0 +1,130 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { _ as parserForExtension, a as formatError, g as parserFor, t as Formats } from "./Serialization-DP9H5bYQ.mjs";
+import { i as defaults, n as acceptHeader } from "./ClientFormats-CXomkXLV.mjs";
+import { n as EvaluationError, r as UpdateError } from "./Errors-CMdV1RhU.mjs";
+import { a as make, n as SparqlEngine } from "./Engine-DF8PN7g-.mjs";
+import { t as QuadStore } from "./Store-DH3Ow1GO.mjs";
+import { i as printPattern } from "./Generator-D3utCJC7.mjs";
+import { c as make$1 } from "./SparqlClient-C_CjXbwj.mjs";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Effect from "effect/Effect";
+import * as Record from "effect/Record";
+import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
+import * as HttpClient from "effect/http/HttpClient";
+import * as HttpClientRequest from "effect/http/HttpClientRequest";
+// src/sparql/Federation.ts
+/**
+* Federation for the in-memory SPARQL engine: an `Engine.ServiceHandler`
+* that evaluates `SERVICE <endpoint> { … }` patterns remotely with the
+* SPARQL client, and an `Engine.Loader` that fetches documents for `LOAD`.
+*
+* ```ts
+* const EngineLive = Federation.layerEngine().pipe(
+*   Layer.provide(Store.layerMemory(data)),
+*   Layer.provide(FetchHttpClient.layer),
+* );
+* ```
+*
+* @since 0.1.0
+*/
+var Federation_exports = /* @__PURE__ */ __exportAll({
+	layerEngine: () => layerEngine,
+	loader: () => loader,
+	serviceHandler: () => serviceHandler,
+	serviceQuery: () => serviceQuery
+});
+/**
+* The query sent to a remote endpoint for a `SERVICE` pattern:
+* `SELECT * WHERE { … }` with the prefixes of the original query.
+*
+* @since 0.1.0
+* @category federation
+*/
+const serviceQuery = (service) => {
+	return `${Record.toEntries(service.prefixes).map(([prefix, iri]) => `PREFIX ${prefix}: <${iri}>\n`).join("")}SELECT * WHERE ${printPattern(service.pattern, service.prefixes)}`;
+};
+const describeError = (e) => Predicate.isTagged(e, "HttpStatusError") ? e.message : `${e._tag}: ${e.message}`;
+/**
+* Builds a `SERVICE` handler that sends each remote pattern to its endpoint
+* with the `HttpClient` from the context. Clients are cached per endpoint.
+*
+* @since 0.1.0
+* @category federation
+*/
+const serviceHandler = (config = {}) => Effect.gen(function* () {
+	const context = yield* Effect.context();
+	const clients = MutableHashMap.empty();
+	const clientFor = (endpoint) => Effect.suspend(() => {
+		const cached = MutableHashMap.get(clients, endpoint.value);
+		if (Option.isSome(cached)) return Effect.succeed(cached.value);
+		return Effect.tap(Effect.provideContext(make$1({
+			...config,
+			endpoint: endpoint.value
+		}), context), (client) => Effect.sync(() => MutableHashMap.set(clients, endpoint.value, client)));
+	});
+	return (endpoint, service) => Stream.unwrap(Effect.map(clientFor(endpoint), (client) => client.selectBindings(serviceQuery(service)).pipe(Stream.mapError((e) => new EvaluationError({
+		message: `SERVICE <${endpoint.value}> failed: ${describeError(e)}`,
+		cause: e
+	}))))).pipe(Stream.withSpan("Federation.service", { attributes: { endpoint: endpoint.value } }));
+});
+const loadFailed = (iri, message, cause) => new UpdateError({
+	message: `LOAD <${iri.value}> failed: ${message}`,
+	cause
+});
+/**
+* Builds a `LOAD` handler that fetches documents over HTTP and parses them
+* with the `Serialization.Formats` service (or the default formats), by
+* media type or, failing that, by file extension.
+*
+* @since 0.1.0
+* @category federation
+*/
+const loader = (config = {}) => Effect.gen(function* () {
+	const http = yield* HttpClient.HttpClient;
+	const formats = Option.getOrElse(yield* Effect.serviceOption(Formats), () => defaults);
+	const accept = acceptHeader(formats);
+	return (iri) => Effect.gen(function* () {
+		const request = HttpClientRequest.get(iri.value, { headers: {
+			...config.headers,
+			accept
+		} });
+		const exchange = Effect.flatMap(http.execute(request), (response) => Effect.map(response.text, (text) => ({
+			response,
+			text
+		})));
+		const { response, text } = yield* (config.timeout === void 0 ? exchange : Effect.timeoutOrElse(exchange, {
+			duration: config.timeout,
+			orElse: () => Effect.fail(loadFailed(iri, "timed out"))
+		})).pipe(Effect.mapError((e) => Predicate.isTagged(e, "UpdateError") ? e : loadFailed(iri, e.message, e)));
+		if (response.status < 200 || response.status >= 300) return yield* loadFailed(iri, `status ${response.status}`);
+		const mediaType = ((response.headers["content-type"] ?? "").split(";", 1)[0] ?? "").trim();
+		const byType = parserFor(formats, mediaType);
+		const extension = new URL(iri.value).pathname.replace(/^.*\./, "");
+		const parser = Option.isSome(byType) ? byType : parserForExtension(formats, extension);
+		if (Option.isNone(parser)) return yield* loadFailed(iri, `unsupported media type '${mediaType}'`);
+		return (yield* parser.value.parse(text, { baseIri: iri.value }).pipe(Effect.mapError((e) => loadFailed(iri, formatError(e), e)))).dataset;
+	}).pipe(Effect.withSpan("Federation.load", { attributes: { iri: iri.value } }));
+});
+/**
+* A `SparqlEngine` layer whose `SERVICE` patterns are evaluated remotely and
+* whose `LOAD` fetches documents over HTTP.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layerEngine = (options = {}, config = {}) => Layer.effect(SparqlEngine, Effect.gen(function* () {
+	const store = yield* QuadStore;
+	const service = yield* serviceHandler(config);
+	const load = yield* loader(config);
+	return make(store, {
+		...options,
+		service: options.service ?? service,
+		load: options.load ?? load
+	});
+}));
+export { serviceQuery as a, serviceHandler as i, layerEngine as n, loader as r, Federation_exports as t };
+
+//# sourceMappingURL=Federation-CHScBkaK.mjs.map

package/dist/Federation-CHScBkaK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Federation-CHScBkaK.mjs","names":["Generator.printPattern","SparqlClient.make","Serialization.Formats","ClientFormats.defaults","ClientFormats.acceptHeader","Serialization.parserFor","Serialization.parserForExtension","Serialization.formatError","Engine.SparqlEngine","Store.QuadStore","Engine.make"],"sources":["../src/sparql/Federation.ts"],"sourcesContent":["/**\n * Federation for the in-memory SPARQL engine: an `Engine.ServiceHandler`\n * that evaluates `SERVICE <endpoint> { … }` patterns remotely with the\n * SPARQL client, and an `Engine.Loader` that fetches documents for `LOAD`.\n *\n * ```ts\n * const EngineLive = Federation.layerEngine().pipe(\n *   Layer.provide(Store.layerMemory(data)),\n *   Layer.provide(FetchHttpClient.layer),\n * );\n * ```\n *\n * @since 0.1.0\n */\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport * as MutableHashMap from 'effect/MutableHashMap';\nimport * as Option from 'effect/Option';\nimport * as Predicate from 'effect/Predicate';\nimport * as Record from 'effect/Record';\nimport * as Stream from 'effect/Stream';\nimport * as HttpClient from 'effect/http/HttpClient';\nimport * as HttpClientRequest from 'effect/http/HttpClientRequest';\nimport * as Serialization from '../Serialization.ts';\nimport type * as Term from '../Term.ts';\nimport * as Engine from './Engine.ts';\nimport { EvaluationError, UpdateError } from './Errors.ts';\nimport * as Generator from './Generator.ts';\nimport * as Store from './Store.ts';\nimport type * as ClientErrors from './ClientErrors.ts';\nimport * as ClientFormats from './ClientFormats.ts';\nimport * as SparqlClient from './SparqlClient.ts';\n\n/**\n * Client settings used for remote endpoints (everything but the endpoint\n * URLs).\n *\n * @since 0.1.0\n * @category models\n */\nexport type RemoteConfig = Omit<\n  SparqlClient.Config,\n  'endpoint' | 'updateEndpoint' | 'graphStoreEndpoint'\n>;\n\n/**\n * The query sent to a remote endpoint for a `SERVICE` pattern:\n * `SELECT * WHERE { … }` with the prefixes of the original query.\n *\n * @since 0.1.0\n * @category federation\n */\nexport const serviceQuery = (service: Parameters<Engine.ServiceHandler>[1]): string => {\n  const prologue = Record.toEntries(service.prefixes)\n    .map(([prefix, iri]) => `PREFIX ${prefix}: <${iri}>\\n`)\n    .join('');\n  return `${prologue}SELECT * WHERE ${Generator.printPattern(service.pattern, service.prefixes)}`;\n};\n\nconst describeError = (e: ClientErrors.SparqlClientError): string =>\n  Predicate.isTagged(e, 'HttpStatusError') ? e.message : `${e._tag}: ${e.message}`;\n\n/**\n * Builds a `SERVICE` handler that sends each remote pattern to its endpoint\n * with the `HttpClient` from the context. Clients are cached per endpoint.\n *\n * @since 0.1.0\n * @category federation\n */\nexport const serviceHandler = (\n  config: RemoteConfig = {},\n): Effect.Effect<Engine.ServiceHandler, never, HttpClient.HttpClient> =>\n  Effect.gen(function* () {\n    const context = yield* Effect.context<HttpClient.HttpClient>();\n    const clients = MutableHashMap.empty<string, SparqlClient.SparqlClientShape>();\n    const clientFor = (endpoint: Term.NamedNode) =>\n      Effect.suspend(() => {\n        const cached = MutableHashMap.get(clients, endpoint.value);\n        if (Option.isSome(cached)) return Effect.succeed(cached.value);\n        return Effect.tap(\n          Effect.provideContext(\n            SparqlClient.make({ ...config, endpoint: endpoint.value }),\n            context,\n          ),\n          (client) => Effect.sync(() => MutableHashMap.set(clients, endpoint.value, client)),\n        );\n      });\n    return (endpoint, service) =>\n      Stream.unwrap(\n        Effect.map(clientFor(endpoint), (client) =>\n          client.selectBindings(serviceQuery(service)).pipe(\n            Stream.mapError(\n              (e) =>\n                new EvaluationError({\n                  message: `SERVICE <${endpoint.value}> failed: ${describeError(e)}`,\n                  cause: e,\n                }),\n            ),\n          ),\n        ),\n      ).pipe(Stream.withSpan('Federation.service', { attributes: { endpoint: endpoint.value } }));\n  });\n\nconst loadFailed = (iri: Term.NamedNode, message: string, cause?: unknown) =>\n  new UpdateError({ message: `LOAD <${iri.value}> failed: ${message}`, cause });\n\n/**\n * Builds a `LOAD` handler that fetches documents over HTTP and parses them\n * with the `Serialization.Formats` service (or the default formats), by\n * media type or, failing that, by file extension.\n *\n * @since 0.1.0\n * @category federation\n */\nexport const loader = (\n  config: Pick<RemoteConfig, 'headers' | 'timeout'> = {},\n): Effect.Effect<Engine.Loader, never, HttpClient.HttpClient> =>\n  Effect.gen(function* () {\n    const http = yield* HttpClient.HttpClient;\n    const formats = Option.getOrElse(\n      yield* Effect.serviceOption(Serialization.Formats),\n      () => ClientFormats.defaults,\n    );\n    const accept = ClientFormats.acceptHeader(formats);\n    return (iri: Term.NamedNode) =>\n      Effect.gen(function* () {\n        const request = HttpClientRequest.get(iri.value, {\n          headers: { ...config.headers, accept },\n        });\n        const exchange = Effect.flatMap(http.execute(request), (response) =>\n          Effect.map(response.text, (text) => ({ response, text })),\n        );\n        const { response, text } = yield* (\n          config.timeout === undefined\n            ? exchange\n            : Effect.timeoutOrElse(exchange, {\n                duration: config.timeout,\n                orElse: () => Effect.fail(loadFailed(iri, 'timed out')),\n              })\n        ).pipe(\n          Effect.mapError((e) =>\n            Predicate.isTagged(e, 'UpdateError') ? e : loadFailed(iri, e.message, e),\n          ),\n        );\n        if (response.status < 200 || response.status >= 300) {\n          return yield* loadFailed(iri, `status ${response.status}`);\n        }\n        const mediaType = ((response.headers['content-type'] ?? '').split(';', 1)[0] ?? '').trim();\n        const byType = Serialization.parserFor(formats, mediaType);\n        const extension = new URL(iri.value).pathname.replace(/^.*\\./, '');\n        const parser = Option.isSome(byType)\n          ? byType\n          : Serialization.parserForExtension(formats, extension);\n        if (Option.isNone(parser)) {\n          return yield* loadFailed(iri, `unsupported media type '${mediaType}'`);\n        }\n        const parsed = yield* parser.value\n          .parse(text, { baseIri: iri.value })\n          .pipe(Effect.mapError((e) => loadFailed(iri, Serialization.formatError(e), e)));\n        return parsed.dataset;\n      }).pipe(Effect.withSpan('Federation.load', { attributes: { iri: iri.value } }));\n  });\n\n/**\n * A `SparqlEngine` layer whose `SERVICE` patterns are evaluated remotely and\n * whose `LOAD` fetches documents over HTTP.\n *\n * @since 0.1.0\n * @category layers\n */\nexport const layerEngine = (\n  options: Engine.EngineOptions = {},\n  config: RemoteConfig = {},\n): Layer.Layer<Engine.SparqlEngine, never, Store.QuadStore | HttpClient.HttpClient> =>\n  Layer.effect(\n    Engine.SparqlEngine,\n    Effect.gen(function* () {\n      const store = yield* Store.QuadStore;\n      const service = yield* serviceHandler(config);\n      const load = yield* loader(config);\n      return Engine.make(store, {\n        ...options,\n        service: options.service ?? service,\n        load: options.load ?? load,\n      });\n    }),\n  );\n"],"mappings":"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"}