@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Optimizer-BWWQRQPY.mjs

@@ -0,0 +1,168 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, K as isTriple, O as defaultGraph, q as isVariable } from "./Term-CFLG1qu4.mjs";
+import { r as emptySet } from "./stringMap-D5YIpYtR.mjs";
+import { a as expressionVariables, i as containsExists, m as mapChildren, n as bgp, r as certainVariables, s as filter, y as transform } from "./Algebra-CGG4oae3.mjs";
+import { t as loop } from "./loop-D5-gNx9K.mjs";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+// src/sparql/Optimizer.ts
+/**
+* A simple, semantics-preserving algebra optimizer:
+*
+* - **Filter pushdown**: conjunctive filter conditions are pushed below
+*   `Join` and into the left side of `LeftJoin` / `Minus` when all their
+*   variables are certainly bound there (and they contain no `EXISTS`).
+* - **BGP join ordering**: the triple patterns of each BGP are reordered
+*   greedily by estimated selectivity (using `QuadStore.estimate` when the
+*   store provides it, and a static heuristic otherwise), preferring
+*   patterns connected to already-bound variables.
+*
+* Patterns inside `EXISTS` are left untouched.
+*
+* @since 0.1.0
+*/
+var Optimizer_exports = /* @__PURE__ */ __exportAll({ optimize: () => optimize });
+const conjuncts = (e) => Predicate.isTagged(e, "Operation") && e.operator === "&&" ? e.args.flatMap(conjuncts) : [e];
+const conjunction = (es) => es.reduce((a, b) => ({
+	_tag: "Operation",
+	operator: "&&",
+	args: [a, b]
+}));
+const subset = (a, b) => Array.from(a).every((x) => b.has(x));
+/** Pushes one filter condition as deep as possible; `None` if it cannot move. */
+const push = (e, op) => {
+	const vars = expressionVariables(e);
+	return Match.value(op).pipe(Match.tag("Join", (j) => {
+		if (subset(vars, certainVariables(j.left))) return Option.some({
+			...j,
+			left: pushOrWrap(e, j.left)
+		});
+		if (subset(vars, certainVariables(j.right))) return Option.some({
+			...j,
+			right: pushOrWrap(e, j.right)
+		});
+		return Option.none();
+	}), Match.tag("LeftJoin", "Minus", (o) => subset(vars, certainVariables(o.left)) ? Option.some({
+		...o,
+		left: pushOrWrap(e, o.left)
+	}) : Option.none()), Match.tag("Filter", (f) => Option.some({
+		...f,
+		input: pushOrWrap(e, f.input)
+	})), Match.orElse(() => Option.none()));
+};
+const pushOrWrap = (e, op) => Option.getOrElse(push(e, op), () => filter(e, op));
+const pushFilters = (op) => transform(op, (o) => {
+	if (!Predicate.isTagged(o, "Filter")) return o;
+	const kept = [];
+	const keep = (input, c) => {
+		kept.push(c);
+		return input;
+	};
+	const input = conjuncts(o.expression).reduce((acc, c) => containsExists(c) ? keep(acc, c) : Option.getOrElse(push(c, acc), () => keep(acc, c)), o.input);
+	return Arr.isReadonlyArrayEmpty(kept) ? input : filter(conjunction(kept), input);
+});
+const positions = (p) => [
+	p.subject,
+	p.predicate,
+	p.object
+];
+const patternVariables = (p) => {
+	const out = [];
+	const go = (t) => {
+		if (isVariable(t)) out.push(t.value);
+		else if (isTriple(t)) {
+			go(t.subject);
+			go(t.predicate);
+			go(t.object);
+		}
+	};
+	positions(p).forEach(go);
+	return out;
+};
+/** A pattern term as a constant: `None` for a variable or a triple pattern with variables. */
+const constant = (t) => {
+	if (isVariable(t)) return Option.none();
+	if (isTriple(t)) {
+		const vars = patternVariables({
+			_tag: "TriplePattern",
+			subject: t.subject,
+			predicate: t.predicate,
+			object: t.object
+		});
+		return Arr.isReadonlyArrayNonEmpty(vars) ? Option.none() : Option.some(t);
+	}
+	return Option.some(t);
+};
+/** Static selectivity heuristic when the store gives no estimates. */
+const staticCost = (p) => (Option.isNone(constant(p.subject)) ? 100 : 1) * (Option.isNone(constant(p.object)) ? 10 : 1) * (Option.isNone(constant(p.predicate)) ? 5 : 1);
+const orderBgp = (patterns, ctx) => Effect.gen(function* () {
+	if (patterns.length < 2) return patterns;
+	const estimate = ctx.store.estimate;
+	const costs = yield* Effect.forEach(patterns, (p) => estimate === void 0 ? Effect.succeed(staticCost(p)) : estimate({
+		subject: Option.getOrUndefined(constant(p.subject)),
+		predicate: Option.getOrUndefined(constant(p.predicate)),
+		object: Option.getOrUndefined(constant(p.object)),
+		graph: Predicate.isTagged(ctx.graph, "NamedGraph") ? ctx.graph.graph : ctx.dataset.defaultGraph === "default" ? defaultGraph : void 0
+	}), { concurrency: 1 });
+	const remaining = Arr.zip(patterns, costs).map(([p, cost]) => ({
+		p,
+		cost,
+		vars: patternVariables(p)
+	}));
+	const bound = emptySet();
+	const out = [];
+	loop(() => {
+		if (!Arr.isArrayNonEmpty(remaining)) return false;
+		const connected = remaining.some((r) => r.vars.some((v) => bound.has(v)));
+		const best = Arr.map(remaining, (r, i) => {
+			const isConnected = r.vars.some((v) => bound.has(v));
+			const eligible = !(connected && !isConnected && bound.size > 0);
+			const boundCount = r.vars.filter((v) => bound.has(v)).length;
+			return {
+				r,
+				i,
+				score: eligible ? r.cost / 10 ** boundCount : Infinity
+			};
+		}).reduce((a, b) => b.score < a.score ? b : a);
+		remaining.splice(best.i, 1);
+		out.push(best.r.p);
+		best.r.vars.forEach((v) => bound.set(v, true));
+		return true;
+	});
+	return out;
+});
+const orderBgps = (op, ctx) => {
+	return Match.value(op).pipe(Match.tag("Bgp", (b) => Effect.map(orderBgp(b.patterns, ctx), (patterns) => bgp(patterns))), Match.tag("Path", "Values", (o) => Effect.succeed(o)), Match.tag("Graph", (g) => Effect.map(orderBgps(g.input, {
+		...ctx,
+		graph: isNamedNode(g.name) ? {
+			_tag: "NamedGraph",
+			graph: g.name
+		} : ctx.graph
+	}), (input) => ({
+		...g,
+		input
+	}))), Match.orElse((o) => {
+		const children = [];
+		mapChildren(o, (c) => {
+			children.push(c);
+			return c;
+		});
+		return Effect.map(Effect.forEach(children, (c) => orderBgps(c, ctx), { concurrency: 1 }), (optimized) => {
+			let i = 0;
+			return mapChildren(o, (c) => optimized[i++] ?? c);
+		});
+	}));
+};
+/**
+* Optimizes an algebra expression.
+*
+* @since 0.1.0
+* @category optimization
+*/
+const optimize = (op, ctx) => orderBgps(pushFilters(op), ctx);
+export { optimize as n, Optimizer_exports as t };
+
+//# sourceMappingURL=Optimizer-BWWQRQPY.mjs.map

package/dist/Optimizer-BWWQRQPY.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Optimizer-BWWQRQPY.mjs","names":["Algebra.expressionVariables","Algebra.certainVariables","Algebra.filter","Algebra.transform","Algebra.containsExists","Term.isVariable","Term.isTriple","Term.defaultGraph","StringMap.emptySet","Algebra.bgp","Term.isNamedNode","Algebra.mapChildren"],"sources":["../src/sparql/Optimizer.ts"],"sourcesContent":["/**\n * A simple, semantics-preserving algebra optimizer:\n *\n * - **Filter pushdown**: conjunctive filter conditions are pushed below\n *   `Join` and into the left side of `LeftJoin` / `Minus` when all their\n *   variables are certainly bound there (and they contain no `EXISTS`).\n * - **BGP join ordering**: the triple patterns of each BGP are reordered\n *   greedily by estimated selectivity (using `QuadStore.estimate` when the\n *   store provides it, and a static heuristic otherwise), preferring\n *   patterns connected to already-bound variables.\n *\n * Patterns inside `EXISTS` are left untouched.\n *\n * @since 0.1.0\n */\nimport * as Arr from 'effect/Array';\nimport * as Effect from 'effect/Effect';\nimport * as Match from 'effect/Match';\nimport * as Option from 'effect/Option';\nimport * as Predicate from 'effect/Predicate';\nimport * as Term from '../Term.ts';\nimport * as Algebra from './Algebra.ts';\nimport type * as Ast from './Ast.ts';\nimport { loop } from './internal/loop.ts';\nimport * as StringMap from './internal/stringMap.ts';\nimport type * as Store from './Store.ts';\n\n/**\n * Inputs of the optimizer.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface OptimizerContext {\n  readonly store: Store.QuadStoreShape;\n  readonly dataset: Store.DatasetSpec;\n  readonly graph: Store.ActiveGraph;\n}\n\nconst conjuncts = (e: Algebra.Expression): Array<Algebra.Expression> =>\n  Predicate.isTagged(e, 'Operation') && e.operator === '&&' ? e.args.flatMap(conjuncts) : [e];\n\nconst conjunction = (es: ReadonlyArray<Algebra.Expression>): Algebra.Expression =>\n  es.reduce((a, b) => ({ _tag: 'Operation', operator: '&&', args: [a, b] }));\n\nconst subset = (a: ReadonlySet<string>, b: ReadonlySet<string>): boolean =>\n  Array.from(a).every((x) => b.has(x));\n\n/** Pushes one filter condition as deep as possible; `None` if it cannot move. */\nconst push = (e: Algebra.Expression, op: Algebra.Operation): Option.Option<Algebra.Operation> => {\n  const vars = Algebra.expressionVariables(e);\n  return Match.value(op).pipe(\n    Match.tag('Join', (j): Option.Option<Algebra.Operation> => {\n      if (subset(vars, Algebra.certainVariables(j.left))) {\n        return Option.some({ ...j, left: pushOrWrap(e, j.left) });\n      }\n      if (subset(vars, Algebra.certainVariables(j.right))) {\n        return Option.some({ ...j, right: pushOrWrap(e, j.right) });\n      }\n      return Option.none();\n    }),\n    Match.tag('LeftJoin', 'Minus', (o) =>\n      subset(vars, Algebra.certainVariables(o.left))\n        ? Option.some({ ...o, left: pushOrWrap(e, o.left) })\n        : Option.none(),\n    ),\n    Match.tag('Filter', (f) => Option.some({ ...f, input: pushOrWrap(e, f.input) })),\n    Match.orElse(() => Option.none()),\n  );\n};\n\nconst pushOrWrap = (e: Algebra.Expression, op: Algebra.Operation): Algebra.Operation =>\n  Option.getOrElse(push(e, op), () => Algebra.filter(e, op));\n\nconst pushFilters = (op: Algebra.Operation): Algebra.Operation =>\n  Algebra.transform(op, (o) => {\n    if (!Predicate.isTagged(o, 'Filter')) return o;\n    // The conditions that stay, and the input with the others pushed in.\n    const kept: Array<Algebra.Expression> = [];\n    const keep = (input: Algebra.Operation, c: Algebra.Expression): Algebra.Operation => {\n      kept.push(c);\n      return input;\n    };\n    const input = conjuncts(o.expression).reduce(\n      (acc, c) =>\n        Algebra.containsExists(c)\n          ? keep(acc, c)\n          : Option.getOrElse(push(c, acc), () => keep(acc, c)),\n      o.input,\n    );\n    return Arr.isReadonlyArrayEmpty(kept) ? input : Algebra.filter(conjunction(kept), input);\n  });\n\nconst positions = (p: Ast.TriplePattern): ReadonlyArray<Ast.TermPattern> => [\n  p.subject,\n  p.predicate,\n  p.object,\n];\n\nconst patternVariables = (p: Ast.TriplePattern): ReadonlyArray<string> => {\n  const out: Array<string> = [];\n  const go = (t: Ast.TermPattern | Term.Term): void => {\n    if (Term.isVariable(t)) out.push(t.value);\n    else if (Term.isTriple(t)) {\n      go(t.subject);\n      go(t.predicate);\n      go(t.object);\n    }\n  };\n  positions(p).forEach(go);\n  return out;\n};\n\n/** A pattern term as a constant: `None` for a variable or a triple pattern with variables. */\nconst constant = (t: Ast.TermPattern): Option.Option<Term.GroundTerm> => {\n  if (Term.isVariable(t)) return Option.none();\n  if (Term.isTriple(t)) {\n    const vars = patternVariables({\n      _tag: 'TriplePattern',\n      subject: t.subject,\n      predicate: t.predicate,\n      object: t.object,\n    });\n    return Arr.isReadonlyArrayNonEmpty(vars) ? Option.none() : Option.some(t);\n  }\n  return Option.some(t);\n};\n\n/** Static selectivity heuristic when the store gives no estimates. */\nconst staticCost = (p: Ast.TriplePattern): number =>\n  (Option.isNone(constant(p.subject)) ? 100 : 1) *\n  (Option.isNone(constant(p.object)) ? 10 : 1) *\n  (Option.isNone(constant(p.predicate)) ? 5 : 1);\n\nconst orderBgp = (\n  patterns: ReadonlyArray<Ast.TriplePattern>,\n  ctx: OptimizerContext,\n): Effect.Effect<ReadonlyArray<Ast.TriplePattern>, Store.StoreError> =>\n  Effect.gen(function* () {\n    if (patterns.length < 2) return patterns;\n    const estimate = ctx.store.estimate;\n    const costs = yield* Effect.forEach(\n      patterns,\n      (p) =>\n        estimate === undefined\n          ? Effect.succeed(staticCost(p))\n          : estimate({\n              subject: Option.getOrUndefined(constant(p.subject)),\n              predicate: Option.getOrUndefined(constant(p.predicate)),\n              object: Option.getOrUndefined(constant(p.object)),\n              graph: Predicate.isTagged(ctx.graph, 'NamedGraph')\n                ? ctx.graph.graph\n                : ctx.dataset.defaultGraph === 'default'\n                  ? Term.defaultGraph\n                  : undefined,\n            }),\n      { concurrency: 1 },\n    );\n    const remaining = Arr.zip(patterns, costs).map(([p, cost]) => ({\n      p,\n      cost,\n      vars: patternVariables(p),\n    }));\n    const bound = StringMap.emptySet();\n    const out: Array<Ast.TriplePattern> = [];\n    // Greedily picks the cheapest pattern, preferring those connected to the bound variables.\n    loop(() => {\n      if (!Arr.isArrayNonEmpty(remaining)) return false;\n      const connected = remaining.some((r) => r.vars.some((v) => bound.has(v)));\n      const scored = Arr.map(remaining, (r, i) => {\n        const isConnected = r.vars.some((v) => bound.has(v));\n        const eligible = !(connected && !isConnected && bound.size > 0);\n        const boundCount = r.vars.filter((v) => bound.has(v)).length;\n        return { r, i, score: eligible ? r.cost / 10 ** boundCount : Infinity };\n      });\n      // The first with the lowest score (the first pattern if none is eligible).\n      const best = scored.reduce((a, b) => (b.score < a.score ? b : a));\n      remaining.splice(best.i, 1);\n      out.push(best.r.p);\n      best.r.vars.forEach((v) => bound.set(v, true));\n      return true;\n    });\n    return out;\n  });\n\nconst orderBgps = (\n  op: Algebra.Operation,\n  ctx: OptimizerContext,\n): Effect.Effect<Algebra.Operation, Store.StoreError> => {\n  return Match.value(op).pipe(\n    Match.tag('Bgp', (b): Effect.Effect<Algebra.Operation, Store.StoreError> =>\n      Effect.map(orderBgp(b.patterns, ctx), (patterns) => Algebra.bgp(patterns)),\n    ),\n    Match.tag('Path', 'Values', (o) => Effect.succeed(o)),\n    Match.tag('Graph', (g) =>\n      Effect.map(\n        orderBgps(g.input, {\n          ...ctx,\n          graph: Term.isNamedNode(g.name) ? { _tag: 'NamedGraph', graph: g.name } : ctx.graph,\n        }),\n        (input) => ({ ...g, input }),\n      ),\n    ),\n    Match.orElse((o) => {\n      const children: Array<Algebra.Operation> = [];\n      Algebra.mapChildren(o, (c) => {\n        children.push(c);\n        return c;\n      });\n      return Effect.map(\n        Effect.forEach(children, (c) => orderBgps(c, ctx), { concurrency: 1 }),\n        (optimized) => {\n          let i = 0;\n          return Algebra.mapChildren(o, (c) => optimized[i++] ?? c);\n        },\n      );\n    }),\n  );\n};\n\n/**\n * Optimizes an algebra expression.\n *\n * @since 0.1.0\n * @category optimization\n */\nexport const optimize = (\n  op: Algebra.Operation,\n  ctx: OptimizerContext,\n): Effect.Effect<Algebra.Operation, Store.StoreError> => orderBgps(pushFilters(op), ctx);\n"],"mappings":"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"}

package/dist/Optimizer-DUpUow6k.d.mts

@@ -0,0 +1,26 @@
+import { g as Operation } from "./Algebra-uGsIEOUA.mjs";
+import { c as StoreError, n as DatasetSpec, o as QuadStoreShape, t as ActiveGraph } from "./Store-D0jmVfb3.mjs";
+import * as Effect from "effect/Effect";
+declare namespace Optimizer_d_exports {
+  export { OptimizerContext, optimize };
+}
+/**
+ * Inputs of the optimizer.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface OptimizerContext {
+  readonly store: QuadStoreShape;
+  readonly dataset: DatasetSpec;
+  readonly graph: ActiveGraph;
+}
+/**
+ * Optimizes an algebra expression.
+ *
+ * @since 0.1.0
+ * @category optimization
+ */
+declare const optimize: (op: Operation, ctx: OptimizerContext) => Effect.Effect<Operation, StoreError>;
+export { Optimizer_d_exports as n, optimize as r, OptimizerContext as t };
+//# sourceMappingURL=Optimizer-DUpUow6k.d.mts.map

package/dist/Options-BLBGL4HE.mjs

@@ -0,0 +1,72 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import * as Result from "effect/Result";
+import * as Duration from "effect/Duration";
+// src/sparql/Options.ts
+/**
+* Server configuration.
+*
+* @since 0.1.0
+*/
+var Options_exports = /* @__PURE__ */ __exportAll({
+	requestPath: () => requestPath,
+	requestUrl: () => requestUrl,
+	resolve: () => resolve
+});
+/** Removes a trailing slash (but not the root's): the path still starts with `/`. */
+const trimSlash = (path) => path.length > 1 && path.endsWith("/") ? `/${path.slice(1, -1)}` : path;
+/**
+* Applies the defaults.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const resolve = (options = {}) => {
+	const path = trimSlash(options.path ?? "/sparql");
+	return {
+		path,
+		updatePath: trimSlash(options.updatePath ?? path),
+		graphStorePath: options.graphStorePath === false ? void 0 : trimSlash(options.graphStorePath ?? "/rdf-graph-store"),
+		baseUrl: options.baseUrl,
+		baseIri: options.baseIri,
+		readOnly: options.readOnly ?? false,
+		queryTimeout: options.queryTimeout === void 0 ? void 0 : Duration.fromInputUnsafe(options.queryTimeout),
+		updateTimeout: options.updateTimeout === void 0 ? void 0 : Duration.fromInputUnsafe(options.updateTimeout),
+		maxResults: options.maxResults,
+		cors: options.cors === true ? {} : options.cors === false ? void 0 : options.cors,
+		logging: options.logging ?? false,
+		serviceDescription: options.serviceDescription ?? true,
+		unionDefaultGraph: options.unionDefaultGraph ?? false,
+		federation: options.federation ?? false,
+		prefixes: options.prefixes ?? {}
+	};
+};
+const stripTrailing = (path) => path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
+/**
+* The absolute URL of a request (without fragment), using `baseUrl`, the
+* request's absolute URL, or its `Host` header.
+*
+* @since 0.1.0
+* @category utils
+*/
+const requestUrl = (request, options) => {
+	const raw = request.originalUrl;
+	const parsed = new URL(raw, "http://localhost");
+	if (options.baseUrl !== void 0) return new URL(parsed.pathname + parsed.search, options.baseUrl);
+	if (/^[a-z][a-z0-9+.-]*:/i.test(raw)) return parsed;
+	const host = request.headers["host"] ?? "localhost";
+	const proto = ((request.headers["x-forwarded-proto"] ?? "http").split(",", 1)[0] ?? "").trim();
+	return new URL(parsed.pathname + parsed.search, `${proto}://${host}`);
+};
+/**
+* The path of a request URL, without query string and trailing slash.
+*
+* @since 0.1.0
+* @category utils
+*/
+const requestPath = (url) => {
+	const pathname = new URL(url, "http://localhost").pathname;
+	return stripTrailing(Result.getOrElse(Result.try(() => decodeURI(pathname)), () => pathname));
+};
+export { resolve as i, requestPath as n, requestUrl as r, Options_exports as t };
+
+//# sourceMappingURL=Options-BLBGL4HE.mjs.map

package/dist/Options-BLBGL4HE.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Options-BLBGL4HE.mjs","names":[],"sources":["../src/sparql/Options.ts"],"sourcesContent":["/**\n * Server configuration.\n *\n * @since 0.1.0\n */\nimport * as Duration from 'effect/Duration';\nimport * as Result from 'effect/Result';\nimport type * as HttpServerRequest from 'effect/http/HttpServerRequest';\n\n/**\n * CORS settings.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface CorsOptions {\n  /** Allowed origins (default: any, `*`). */\n  readonly allowedOrigins?: ReadonlyArray<string> | undefined;\n  /** Allowed request headers (default: whatever the preflight asks for). */\n  readonly allowedHeaders?: ReadonlyArray<string> | undefined;\n  /** Response headers exposed to scripts. */\n  readonly exposedHeaders?: ReadonlyArray<string> | undefined;\n  /** Preflight cache duration in seconds. */\n  readonly maxAge?: number | undefined;\n  /** Whether to allow credentials. */\n  readonly credentials?: boolean | undefined;\n}\n\n/**\n * Server options. Every field is optional.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Options {\n  /** Path of the SPARQL query endpoint (default `/sparql`). */\n  readonly path?: `/${string}` | undefined;\n  /**\n   * Path of the SPARQL update endpoint (default: the query endpoint, which\n   * then accepts both).\n   */\n  readonly updatePath?: `/${string}` | undefined;\n  /**\n   * Path of the Graph Store Protocol endpoint (default `/rdf-graph-store`),\n   * or `false` to disable it. Graphs are identified indirectly with\n   * `?default` / `?graph=<iri>` on this path, or directly by any URL below it.\n   */\n  readonly graphStorePath?: `/${string}` | false | undefined;\n  /**\n   * The public origin of the server (e.g. `https://data.example.org`), used to\n   * build the request URLs that serve as base IRIs and as directly\n   * identified graph IRIs. Defaults to the request's `Host` header (and\n   * `X-Forwarded-Proto`).\n   */\n  readonly baseUrl?: string | undefined;\n  /**\n   * The base IRI for queries and updates. Defaults to the endpoint URL, as\n   * suggested by the protocol.\n   */\n  readonly baseIri?: string | undefined;\n  /** Rejects updates and Graph Store writes (default `false`). */\n  readonly readOnly?: boolean | undefined;\n  /**\n   * Time limit for evaluating a query. A query that produces no result in\n   * time is answered with `503 Service Unavailable`; a streaming response\n   * that exceeds it is aborted.\n   */\n  readonly queryTimeout?: Duration.Input | undefined;\n  /** Time limit for an update request (`503` when exceeded). */\n  readonly updateTimeout?: Duration.Input | undefined;\n  /** The maximum number of solutions or triples returned by a query. */\n  readonly maxResults?: number | undefined;\n  /** Enables CORS (`true` for permissive defaults). */\n  readonly cors?: boolean | CorsOptions | undefined;\n  /** Logs every request with Effect logging (default `false` for the handler). */\n  readonly logging?: boolean | undefined;\n  /** Serve a service description on `GET` without a query (default `true`). */\n  readonly serviceDescription?: boolean | undefined;\n  /** Advertised in the service description: `sd:UnionDefaultGraph`. */\n  readonly unionDefaultGraph?: boolean | undefined;\n  /** Advertised in the service description: `sd:BasicFederatedQuery`. */\n  readonly federation?: boolean | undefined;\n  /** Prefixes used when serialising graphs in syntaxes that support them. */\n  readonly prefixes?: Readonly<Record<string, string>> | undefined;\n}\n\n/**\n * Options with defaults applied.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Resolved {\n  readonly path: `/${string}`;\n  readonly updatePath: `/${string}`;\n  readonly graphStorePath: `/${string}` | undefined;\n  readonly baseUrl: string | undefined;\n  readonly baseIri: string | undefined;\n  readonly readOnly: boolean;\n  readonly queryTimeout: Duration.Duration | undefined;\n  readonly updateTimeout: Duration.Duration | undefined;\n  readonly maxResults: number | undefined;\n  readonly cors: CorsOptions | undefined;\n  readonly logging: boolean;\n  readonly serviceDescription: boolean;\n  readonly unionDefaultGraph: boolean;\n  readonly federation: boolean;\n  readonly prefixes: Readonly<Record<string, string>>;\n}\n\n/** Removes a trailing slash (but not the root's): the path still starts with `/`. */\nconst trimSlash = (path: `/${string}`): `/${string}` =>\n  path.length > 1 && path.endsWith('/') ? `/${path.slice(1, -1)}` : path;\n\n/**\n * Applies the defaults.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const resolve = (options: Options = {}): Resolved => {\n  const path = trimSlash(options.path ?? '/sparql');\n  return {\n    path,\n    updatePath: trimSlash(options.updatePath ?? path),\n    graphStorePath:\n      options.graphStorePath === false\n        ? undefined\n        : trimSlash(options.graphStorePath ?? '/rdf-graph-store'),\n    baseUrl: options.baseUrl,\n    baseIri: options.baseIri,\n    readOnly: options.readOnly ?? false,\n    queryTimeout:\n      options.queryTimeout === undefined\n        ? undefined\n        : Duration.fromInputUnsafe(options.queryTimeout),\n    updateTimeout:\n      options.updateTimeout === undefined\n        ? undefined\n        : Duration.fromInputUnsafe(options.updateTimeout),\n    maxResults: options.maxResults,\n    cors: options.cors === true ? {} : options.cors === false ? undefined : options.cors,\n    logging: options.logging ?? false,\n    serviceDescription: options.serviceDescription ?? true,\n    unionDefaultGraph: options.unionDefaultGraph ?? false,\n    federation: options.federation ?? false,\n    prefixes: options.prefixes ?? {},\n  };\n};\n\nconst stripTrailing = (path: string): string =>\n  path.length > 1 && path.endsWith('/') ? path.slice(0, -1) : path;\n\n/**\n * The absolute URL of a request (without fragment), using `baseUrl`, the\n * request's absolute URL, or its `Host` header.\n *\n * @since 0.1.0\n * @category utils\n */\nexport const requestUrl = (\n  request: HttpServerRequest.HttpServerRequest,\n  options: Resolved,\n): URL => {\n  const raw = request.originalUrl;\n  const parsed = new URL(raw, 'http://localhost');\n  if (options.baseUrl !== undefined) {\n    return new URL(parsed.pathname + parsed.search, options.baseUrl);\n  }\n  if (/^[a-z][a-z0-9+.-]*:/i.test(raw)) return parsed;\n  const host = request.headers['host'] ?? 'localhost';\n  const proto = ((request.headers['x-forwarded-proto'] ?? 'http').split(',', 1)[0] ?? '').trim();\n  return new URL(parsed.pathname + parsed.search, `${proto}://${host}`);\n};\n\n/**\n * The path of a request URL, without query string and trailing slash.\n *\n * @since 0.1.0\n * @category utils\n */\nexport const requestPath = (url: string): string => {\n  const pathname = new URL(url, 'http://localhost').pathname;\n  // A malformed percent-encoding is matched as written.\n  return stripTrailing(\n    Result.getOrElse(\n      Result.try(() => decodeURI(pathname)),\n      () => pathname,\n    ),\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;AA+GA,MAAM,aAAa,SACjB,KAAK,SAAS,KAAK,KAAK,SAAS,GAAG,IAAI,IAAI,KAAK,MAAM,GAAG,EAAE,MAAM;;;;;;;AAQpE,MAAa,WAAW,UAAmB,CAAC,MAAgB;CAC1D,MAAM,OAAO,UAAU,QAAQ,QAAQ,SAAS;CAChD,OAAO;EACL;EACA,YAAY,UAAU,QAAQ,cAAc,IAAI;EAChD,gBACE,QAAQ,mBAAmB,QACvB,KAAA,IACA,UAAU,QAAQ,kBAAkB,kBAAkB;EAC5D,SAAS,QAAQ;EACjB,SAAS,QAAQ;EACjB,UAAU,QAAQ,YAAY;EAC9B,cACE,QAAQ,iBAAiB,KAAA,IACrB,KAAA,IACA,SAAS,gBAAgB,QAAQ,YAAY;EACnD,eACE,QAAQ,kBAAkB,KAAA,IACtB,KAAA,IACA,SAAS,gBAAgB,QAAQ,aAAa;EACpD,YAAY,QAAQ;EACpB,MAAM,QAAQ,SAAS,OAAO,CAAC,IAAI,QAAQ,SAAS,QAAQ,KAAA,IAAY,QAAQ;EAChF,SAAS,QAAQ,WAAW;EAC5B,oBAAoB,QAAQ,sBAAsB;EAClD,mBAAmB,QAAQ,qBAAqB;EAChD,YAAY,QAAQ,cAAc;EAClC,UAAU,QAAQ,YAAY,CAAC;CACjC;AACF;AAEA,MAAM,iBAAiB,SACrB,KAAK,SAAS,KAAK,KAAK,SAAS,GAAG,IAAI,KAAK,MAAM,GAAG,EAAE,IAAI;;;;;;;;AAS9D,MAAa,cACX,SACA,YACQ;CACR,MAAM,MAAM,QAAQ;CACpB,MAAM,SAAS,IAAI,IAAI,KAAK,kBAAkB;CAC9C,IAAI,QAAQ,YAAY,KAAA,GACtB,OAAO,IAAI,IAAI,OAAO,WAAW,OAAO,QAAQ,QAAQ,OAAO;CAEjE,IAAI,uBAAuB,KAAK,GAAG,GAAG,OAAO;CAC7C,MAAM,OAAO,QAAQ,QAAQ,WAAW;CACxC,MAAM,UAAU,QAAQ,QAAQ,wBAAwB,OAAA,CAAQ,MAAM,KAAK,CAAC,CAAC,CAAC,MAAM,GAAA,CAAI,KAAK;CAC7F,OAAO,IAAI,IAAI,OAAO,WAAW,OAAO,QAAQ,GAAG,MAAM,KAAK,MAAM;AACtE;;;;;;;AAQA,MAAa,eAAe,QAAwB;CAClD,MAAM,WAAW,IAAI,IAAI,KAAK,kBAAkB,CAAC,CAAC;CAElD,OAAO,cACL,OAAO,UACL,OAAO,UAAU,UAAU,QAAQ,CAAC,SAC9B,QACR,CACF;AACF"}

package/dist/Options-BommQwP9.d.mts

@@ -0,0 +1,127 @@
+import * as Duration from "effect/Duration";
+import * as HttpServerRequest from "effect/http/HttpServerRequest";
+declare namespace Options_d_exports {
+  export { CorsOptions, Options, Resolved, requestPath, requestUrl, resolve };
+}
+/**
+ * CORS settings.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface CorsOptions {
+  /** Allowed origins (default: any, `*`). */
+  readonly allowedOrigins?: ReadonlyArray<string> | undefined;
+  /** Allowed request headers (default: whatever the preflight asks for). */
+  readonly allowedHeaders?: ReadonlyArray<string> | undefined;
+  /** Response headers exposed to scripts. */
+  readonly exposedHeaders?: ReadonlyArray<string> | undefined;
+  /** Preflight cache duration in seconds. */
+  readonly maxAge?: number | undefined;
+  /** Whether to allow credentials. */
+  readonly credentials?: boolean | undefined;
+}
+/**
+ * Server options. Every field is optional.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Options {
+  /** Path of the SPARQL query endpoint (default `/sparql`). */
+  readonly path?: `/${string}` | undefined;
+  /**
+   * Path of the SPARQL update endpoint (default: the query endpoint, which
+   * then accepts both).
+   */
+  readonly updatePath?: `/${string}` | undefined;
+  /**
+   * Path of the Graph Store Protocol endpoint (default `/rdf-graph-store`),
+   * or `false` to disable it. Graphs are identified indirectly with
+   * `?default` / `?graph=<iri>` on this path, or directly by any URL below it.
+   */
+  readonly graphStorePath?: `/${string}` | false | undefined;
+  /**
+   * The public origin of the server (e.g. `https://data.example.org`), used to
+   * build the request URLs that serve as base IRIs and as directly
+   * identified graph IRIs. Defaults to the request's `Host` header (and
+   * `X-Forwarded-Proto`).
+   */
+  readonly baseUrl?: string | undefined;
+  /**
+   * The base IRI for queries and updates. Defaults to the endpoint URL, as
+   * suggested by the protocol.
+   */
+  readonly baseIri?: string | undefined;
+  /** Rejects updates and Graph Store writes (default `false`). */
+  readonly readOnly?: boolean | undefined;
+  /**
+   * Time limit for evaluating a query. A query that produces no result in
+   * time is answered with `503 Service Unavailable`; a streaming response
+   * that exceeds it is aborted.
+   */
+  readonly queryTimeout?: Duration.Input | undefined;
+  /** Time limit for an update request (`503` when exceeded). */
+  readonly updateTimeout?: Duration.Input | undefined;
+  /** The maximum number of solutions or triples returned by a query. */
+  readonly maxResults?: number | undefined;
+  /** Enables CORS (`true` for permissive defaults). */
+  readonly cors?: boolean | CorsOptions | undefined;
+  /** Logs every request with Effect logging (default `false` for the handler). */
+  readonly logging?: boolean | undefined;
+  /** Serve a service description on `GET` without a query (default `true`). */
+  readonly serviceDescription?: boolean | undefined;
+  /** Advertised in the service description: `sd:UnionDefaultGraph`. */
+  readonly unionDefaultGraph?: boolean | undefined;
+  /** Advertised in the service description: `sd:BasicFederatedQuery`. */
+  readonly federation?: boolean | undefined;
+  /** Prefixes used when serialising graphs in syntaxes that support them. */
+  readonly prefixes?: Readonly<Record<string, string>> | undefined;
+}
+/**
+ * Options with defaults applied.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Resolved {
+  readonly path: `/${string}`;
+  readonly updatePath: `/${string}`;
+  readonly graphStorePath: `/${string}` | undefined;
+  readonly baseUrl: string | undefined;
+  readonly baseIri: string | undefined;
+  readonly readOnly: boolean;
+  readonly queryTimeout: Duration.Duration | undefined;
+  readonly updateTimeout: Duration.Duration | undefined;
+  readonly maxResults: number | undefined;
+  readonly cors: CorsOptions | undefined;
+  readonly logging: boolean;
+  readonly serviceDescription: boolean;
+  readonly unionDefaultGraph: boolean;
+  readonly federation: boolean;
+  readonly prefixes: Readonly<Record<string, string>>;
+}
+/**
+ * Applies the defaults.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const resolve: (options?: Options) => Resolved;
+/**
+ * The absolute URL of a request (without fragment), using `baseUrl`, the
+ * request's absolute URL, or its `Host` header.
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const requestUrl: (request: HttpServerRequest.HttpServerRequest, options: Resolved) => URL;
+/**
+ * The path of a request URL, without query string and trailing slash.
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const requestPath: (url: string) => string;
+export { requestPath as a, Resolved as i, Options as n, requestUrl as o, Options_d_exports as r, resolve as s, CorsOptions as t };
+//# sourceMappingURL=Options-BommQwP9.d.mts.map

package/dist/Packet-CA76wVX3.mjs

@@ -0,0 +1,197 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Order from "effect/Order";
+// src/xmp/Packet.ts
+/**
+* XMP packets (ISO 16684-1 §7.3): finding `<?xpacket begin=… ?>` …
+* `<?xpacket end="w"?>` in arbitrary bytes, and wrapping serialized XMP in
+* a packet with the whitespace padding that lets a writer update it in
+* place.
+*
+* Packets are found in UTF-8, UTF-16 and UTF-32 (either byte order), the
+* encodings ISO 16684-1 §7.3.2 lets a packet use and a byte scanner can
+* recognise without parsing the host file.
+*
+* @since 0.1.0
+*/
+var Packet_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_PADDING: () => DEFAULT_PADDING,
+	PACKET_ID: () => PACKET_ID,
+	byteLength: () => byteLength,
+	find: () => find,
+	findAll: () => findAll,
+	padding: () => padding,
+	unwrap: () => unwrap,
+	wrap: () => wrap,
+	wrapToSize: () => wrapToSize
+});
+/**
+* The `id` attribute every packet header carries.
+*
+* @since 0.1.0
+* @category constants
+*/
+const PACKET_ID = "W5M0MpCehiHzreSzNTczkc9d";
+/**
+* The padding a writable packet gets by default: 2 KiB, as the XMP
+* specification recommends.
+*
+* @since 0.1.0
+* @category constants
+*/
+const DEFAULT_PADDING = 2048;
+const HEADER = "<?xpacket begin=";
+const TRAILER = "<?xpacket end=";
+const PI_END = "?>";
+const ENCODINGS = [
+	"utf-8",
+	"utf-16be",
+	"utf-16le",
+	"utf-32be",
+	"utf-32le"
+];
+const WIDTHS = {
+	"utf-8": 1,
+	"utf-16be": 2,
+	"utf-16le": 2,
+	"utf-32be": 4,
+	"utf-32le": 4
+};
+const isLittleEndian = (encoding) => encoding.endsWith("le");
+/** One ASCII code unit in an encoding: the code, zero-padded to the unit's width. */
+const asciiUnit = (code, encoding) => {
+	const padding = Array.from({ length: WIDTHS[encoding] - 1 }, () => 0);
+	return isLittleEndian(encoding) ? [code, ...padding] : [...padding, code];
+};
+const encodeAscii = (text, encoding) => Uint8Array.from(Arr.flatMap(Arr.fromIterable(text), (c) => asciiUnit(c.charCodeAt(0), encoding)));
+/**
+* Decodes UTF-32, which the WHATWG `TextDecoder` does not support. A code
+* point outside Unicode, or a surrogate, decodes to U+FFFD as `TextDecoder`
+* would.
+*/
+const decodeUtf32 = (bytes, littleEndian) => {
+	const data = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const units = Math.floor(bytes.length / 4);
+	return Array.from({ length: units }, (_, i) => {
+		const code = data.getUint32(i * 4, littleEndian);
+		return code > 1114111 || code >= 55296 && code <= 57343 ? "�" : String.fromCodePoint(code);
+	}).join("");
+};
+const decode = (bytes, encoding) => WIDTHS[encoding] === 4 ? decodeUtf32(bytes, isLittleEndian(encoding)) : new TextDecoder(encoding).decode(bytes);
+const bytesToString = (bytes) => new TextDecoder("windows-1252").decode(bytes);
+const marker = (text, encoding) => bytesToString(encodeAscii(text, encoding));
+const indexIn = (haystack, needle, from) => {
+	const i = haystack.indexOf(needle, from);
+	return i < 0 ? Option.none() : Option.some(i);
+};
+const isWritable = (text, trailer) => text.charAt(trailer + 14 + 1) === "w";
+const findIn = (bytes, haystack, from) => {
+	const starts = Arr.getSomes(Arr.map(ENCODINGS, (encoding) => Option.map(indexIn(haystack, marker(HEADER, encoding), from), (offset) => ({
+		offset,
+		encoding
+	}))));
+	const first = Arr.head(Arr.sort(starts, Order.mapInput(Order.Number, (s) => s.offset)));
+	return Option.flatMap(first, ({ offset, encoding }) => {
+		const width = WIDTHS[encoding];
+		const end = Option.flatMap(indexIn(haystack, marker(TRAILER, encoding), offset + 16 * width), (trailer) => Option.map(indexIn(haystack, marker(PI_END, encoding), trailer + 14 * width), (close) => close + 2 * width));
+		return Option.map(end, (close) => {
+			const text = decode(bytes.subarray(offset, close), encoding);
+			return {
+				offset,
+				length: close - offset,
+				encoding,
+				writable: isWritable(text, text.lastIndexOf(TRAILER)),
+				text
+			};
+		});
+	});
+};
+/**
+* Finds the first packet at or after `fromIndex` in a byte sequence: a file
+* of any format, scanned without parsing it (ISO 16684-1 §7.3.2's packet
+* scanning).
+*
+* @since 0.1.0
+* @category scanning
+*/
+const find = (bytes, fromIndex = 0) => findIn(bytes, bytesToString(bytes), fromIndex);
+/**
+* Finds every packet in a byte sequence, in order.
+*
+* @since 0.1.0
+* @category scanning
+*/
+const findAll = (bytes) => {
+	const haystack = bytesToString(bytes);
+	return Arr.unfold(0, (from) => Option.map(findIn(bytes, haystack, from), (p) => [p, p.offset + p.length]));
+};
+/**
+* Splits a packet's text into the serialized XMP, the padding and the
+* writability of its trailer. Returns `None` when the text is not a packet.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const unwrap = (text) => Option.flatMap(indexIn(text, HEADER, 0), (start) => Option.flatMap(indexIn(text, PI_END, start), (headerEnd) => {
+	const trailer = text.lastIndexOf(TRAILER);
+	if (trailer < headerEnd) return Option.none();
+	const content = text.slice(headerEnd + 2, trailer).replace(/^\r?\n/, "");
+	const xml = content.trimEnd();
+	return Option.some({
+		xml,
+		padding: content.length - xml.length,
+		writable: isWritable(text, trailer)
+	});
+}));
+const header = `<?xpacket begin="" id="${PACKET_ID}"?>\n`;
+const trailerOf = (writable) => `<?xpacket end="${writable ? "w" : "r"}"?>`;
+/**
+* Whitespace padding of exactly `bytes` bytes: lines of 99 spaces and a
+* newline, as XMP writers lay it out.
+*
+* @since 0.1.0
+* @category serializing
+*/
+const padding = (bytes) => {
+	const lines = Math.floor(bytes / 100);
+	return `${`${" ".repeat(99)}\n`.repeat(lines)}${" ".repeat(bytes - lines * 100)}`;
+};
+const body = (xml) => xml.endsWith("\n") ? xml : `${xml}\n`;
+/**
+* Wraps serialized XMP (an `<x:xmpmeta>` element) in a UTF-8 packet.
+*
+* @since 0.1.0
+* @category serializing
+*/
+const wrap = (xml, options) => {
+	const writable = options?.writable ?? true;
+	const pad = options?.padding ?? (writable ? 2048 : 0);
+	return `${header}${body(xml)}${padding(pad)}${trailerOf(writable)}`;
+};
+/**
+* The UTF-8 byte length of a string.
+*
+* @since 0.1.0
+* @category serializing
+*/
+const byteLength = (text) => new TextEncoder().encode(text).length;
+/**
+* Wraps serialized XMP in a UTF-8 packet of exactly `size` bytes, padding the
+* difference: how an XMP packet is updated in place in a file. Returns
+* `None` when the XMP does not fit.
+*
+* @since 0.1.0
+* @category serializing
+*/
+const wrapToSize = (xml, size, options) => {
+	const writable = options?.writable ?? true;
+	const fixed = byteLength(`${header}${body(xml)}${trailerOf(writable)}`);
+	return fixed > size ? Option.none() : Option.some(wrap(xml, {
+		writable,
+		padding: size - fixed
+	}));
+};
+export { find as a, unwrap as c, byteLength as i, wrap as l, PACKET_ID as n, findAll as o, Packet_exports as r, padding as s, DEFAULT_PADDING as t, wrapToSize as u };
+
+//# sourceMappingURL=Packet-CA76wVX3.mjs.map