@dwk/ldn 0.1.0-beta.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026 David W. Keith
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,56 @@
+# `@dwk/ldn`
+
+[Linked Data Notifications](https://www.w3.org/TR/ldn/) (W3C LDN) primitives. A
+pure, RDF-only, **protocol-agnostic** library: it implements the three LDN roles
+as plain-data functions over [`@dwk/rdf`](../rdf)'s flat `StoredQuad`
+representation, with no Cloudflare bindings, no transport, and **no Solid/WAC
+assumptions**. The same primitives back the [`@dwk/solid-pod`](../solid-pod)
+inbox (discovery) and the [`@dwk/activitypub`](../activitypub) inbox
+(advertisement) without either standard leaking into the other.
+
+See the [spec](../../spec/packages/ldn.md) for the authoritative requirements.
+
+## What it does
+
+- **Discovery** — advertise an inbox with `inboxLinkHeader(inboxIri)` (an
+  `ldp:inbox` `Link` value) or `inboxTriple(subject, inbox)` (the in-body
+  triple), and find one from the consumer side with `parseInboxLinks(header)` or
+  `discoverInboxIris(quads, subject?)`.
+- **Receiver** — `parseNotification(body, contentType, { baseIRI })` validates a
+  posted RDF notification, throwing a `NotificationProblem` that carries the HTTP
+  status to answer (`415` for a non-RDF media type, `400` for a body that does
+  not parse or has no triples) and otherwise returning the parsed `StoredQuad`s.
+- **Consumer** — `inboxListingQuads(inbox, members)` builds the `ldp:Container` +
+  `ldp:contains` listing triples; `listInboxMembers(quads, inbox?)` reads them
+  back.
+
+Authorization, deduplication, and storage are the **caller's** concern — this
+library only speaks RDF and the LDN vocabulary.
+
+## Usage
+
+```ts
+import {
+  inboxLinkHeader,
+  parseNotification,
+  NotificationProblem,
+} from "@dwk/ldn";
+
+// Producer: advertise the inbox on a target resource's response.
+response.headers.set("link", inboxLinkHeader("https://alice.example/inbox/"));
+
+// Receiver: validate an inbound notification before persisting it.
+try {
+  const { quads } = await parseNotification(
+    await request.text(),
+    request.headers.get("content-type"),
+    { baseIRI: inboxIri },
+  );
+  // …authorize, dedup, and store `quads`…
+} catch (error) {
+  if (error instanceof NotificationProblem) {
+    return new Response(error.message, { status: error.status });
+  }
+  throw error;
+}
+```

package/dist/discovery.d.ts

@@ -0,0 +1,50 @@
+/**
+ * LDN inbox discovery — both sides of the wire.
+ *
+ * A target resource advertises its inbox so a sender can find it. LDN allows the
+ * advertisement to travel either in an HTTP `Link` header or as an `ldp:inbox`
+ * triple in the resource's RDF body, so this module covers building the header
+ * (and triple) on the producer side and parsing both forms on the consumer side.
+ *
+ * It depends on `@dwk/rdf` for *types only* (erased at build), so it carries no
+ * RDF-parser runtime. It is re-exported from the package root and also reachable
+ * directly as `@dwk/ldn/discovery`, the n3-free entry point a binding-bound
+ * consumer (e.g. a Workers runtime) imports to advertise an inbox without
+ * pulling in the notification parser.
+ */
+import type { StoredQuad } from "@dwk/rdf";
+/**
+ * Build the `Link` header value advertising `inboxIri` as the resource's inbox:
+ * `<inboxIri>; rel="http://www.w3.org/ns/ldp#inbox"`. Join it with any other
+ * link-values using `, ` to form a complete header.
+ */
+export declare function inboxLinkHeader(inboxIri: string): string;
+/**
+ * Build the `Link` header value advertising `constraintsIri` as the constraints
+ * a resource imposes: `<constraintsIri>; rel="http://www.w3.org/ns/ldp#constrainedBy"`.
+ * LDN §5.1 (and LDP) lets a receiver point senders at a document describing the
+ * constraints it enforces — the media types it accepts, whether it requires a
+ * non-empty graph, and so on. Join it with any other link-values using `, `.
+ */
+export declare function constrainedByLinkHeader(constraintsIri: string): string;
+/**
+ * Build the `<subjectIri> ldp:inbox <inboxIri>` triple that advertises the inbox
+ * inside a resource's RDF body (the alternative to the `Link` header).
+ */
+export declare function inboxTriple(subjectIri: string, inboxIri: string): StoredQuad;
+/**
+ * Extract the inbox IRIs a graph advertises via `ldp:inbox`. When `subjectIri`
+ * is given, only triples with that subject are considered (the usual case: "what
+ * is _this_ resource's inbox?"); otherwise every `ldp:inbox` object is returned.
+ * Only named-node objects count — a literal `ldp:inbox` is not a dereferenceable
+ * inbox. Results are de-duplicated, preserving first-seen order.
+ */
+export declare function discoverInboxIris(quads: readonly StoredQuad[], subjectIri?: string): string[];
+/**
+ * Parse the inbox IRIs advertised by an HTTP `Link` header. A link-value counts
+ * when its `rel` token list includes the full `ldp:inbox` IRI (LDN's canonical
+ * form) or the bare `inbox` token. Returns de-duplicated, first-seen-order IRIs;
+ * an absent or malformed header yields an empty list.
+ */
+export declare function parseInboxLinks(linkHeader: string | null): string[];
+//# sourceMappingURL=discovery.d.ts.map

package/dist/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../src/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAM3C;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,CAO5E;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,EAAE,CASV;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,EAAE,CAYnE"}

package/dist/discovery.js

@@ -0,0 +1,165 @@
+/**
+ * LDN inbox discovery — both sides of the wire.
+ *
+ * A target resource advertises its inbox so a sender can find it. LDN allows the
+ * advertisement to travel either in an HTTP `Link` header or as an `ldp:inbox`
+ * triple in the resource's RDF body, so this module covers building the header
+ * (and triple) on the producer side and parsing both forms on the consumer side.
+ *
+ * It depends on `@dwk/rdf` for *types only* (erased at build), so it carries no
+ * RDF-parser runtime. It is re-exported from the package root and also reachable
+ * directly as `@dwk/ldn/discovery`, the n3-free entry point a binding-bound
+ * consumer (e.g. a Workers runtime) imports to advertise an inbox without
+ * pulling in the notification parser.
+ */
+import { LDP_INBOX, LDP_CONSTRAINED_BY } from "./vocab";
+const DEFAULT_GRAPH = { termType: "DefaultGraph", value: "" };
+/**
+ * Build the `Link` header value advertising `inboxIri` as the resource's inbox:
+ * `<inboxIri>; rel="http://www.w3.org/ns/ldp#inbox"`. Join it with any other
+ * link-values using `, ` to form a complete header.
+ */
+export function inboxLinkHeader(inboxIri) {
+    return `<${inboxIri}>; rel="${LDP_INBOX}"`;
+}
+/**
+ * Build the `Link` header value advertising `constraintsIri` as the constraints
+ * a resource imposes: `<constraintsIri>; rel="http://www.w3.org/ns/ldp#constrainedBy"`.
+ * LDN §5.1 (and LDP) lets a receiver point senders at a document describing the
+ * constraints it enforces — the media types it accepts, whether it requires a
+ * non-empty graph, and so on. Join it with any other link-values using `, `.
+ */
+export function constrainedByLinkHeader(constraintsIri) {
+    return `<${constraintsIri}>; rel="${LDP_CONSTRAINED_BY}"`;
+}
+/**
+ * Build the `<subjectIri> ldp:inbox <inboxIri>` triple that advertises the inbox
+ * inside a resource's RDF body (the alternative to the `Link` header).
+ */
+export function inboxTriple(subjectIri, inboxIri) {
+    return {
+        subject: { termType: "NamedNode", value: subjectIri },
+        predicate: { termType: "NamedNode", value: LDP_INBOX },
+        object: { termType: "NamedNode", value: inboxIri },
+        graph: DEFAULT_GRAPH,
+    };
+}
+/**
+ * Extract the inbox IRIs a graph advertises via `ldp:inbox`. When `subjectIri`
+ * is given, only triples with that subject are considered (the usual case: "what
+ * is _this_ resource's inbox?"); otherwise every `ldp:inbox` object is returned.
+ * Only named-node objects count — a literal `ldp:inbox` is not a dereferenceable
+ * inbox. Results are de-duplicated, preserving first-seen order.
+ */
+export function discoverInboxIris(quads, subjectIri) {
+    const found = new Set();
+    for (const quad of quads) {
+        if (quad.predicate.value !== LDP_INBOX)
+            continue;
+        if (quad.object.termType !== "NamedNode")
+            continue;
+        if (subjectIri !== undefined && quad.subject.value !== subjectIri)
+            continue;
+        found.add(quad.object.value);
+    }
+    return [...found];
+}
+/**
+ * Parse the inbox IRIs advertised by an HTTP `Link` header. A link-value counts
+ * when its `rel` token list includes the full `ldp:inbox` IRI (LDN's canonical
+ * form) or the bare `inbox` token. Returns de-duplicated, first-seen-order IRIs;
+ * an absent or malformed header yields an empty list.
+ */
+export function parseInboxLinks(linkHeader) {
+    if (!linkHeader)
+        return [];
+    const found = new Set();
+    for (const entry of splitLinkValues(linkHeader)) {
+        const start = entry.indexOf("<");
+        const end = entry.indexOf(">", start + 1);
+        if (start === -1 || end === -1)
+            continue;
+        const uri = entry.slice(start + 1, end).trim();
+        if (uri.length === 0)
+            continue;
+        if (linkEntryRelIsInbox(entry.slice(end + 1)))
+            found.add(uri);
+    }
+    return [...found];
+}
+/**
+ * Split a `Link` header into its individual link-values on top-level commas,
+ * tracking both quoted parameter values and `<…>` URI-references so a comma
+ * inside either never splits an entry (RFC 8288). A simple `,`-followed-by-`<`
+ * regex would mis-split a quoted parameter such as `title="a, <b>"`.
+ */
+function splitLinkValues(header) {
+    const values = [];
+    let inQuotes = false;
+    let inBrackets = false;
+    let current = "";
+    for (let i = 0; i < header.length; i++) {
+        const char = header[i];
+        if (char === '"' && header[i - 1] !== "\\") {
+            inQuotes = !inQuotes;
+        }
+        else if (char === "<" && !inQuotes) {
+            inBrackets = true;
+        }
+        else if (char === ">" && !inQuotes) {
+            inBrackets = false;
+        }
+        if (char === "," && !inQuotes && !inBrackets) {
+            values.push(current);
+            current = "";
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current.trim() !== "")
+        values.push(current);
+    return values;
+}
+/**
+ * Whether a link-value's parameter string declares `rel` naming the inbox. `rel`
+ * is a space-separated token list, so `rel="http://www.w3.org/ns/ldp#inbox"` and
+ * `rel="inbox alternate"` both count. Parameters are split on top-level `;`
+ * (respecting quotes) so a `rel=...` substring inside another quoted parameter
+ * value is not mistaken for the rel parameter.
+ */
+function linkEntryRelIsInbox(params) {
+    for (const param of splitLinkParams(params)) {
+        const match = /^\s*rel\s*=\s*("([^"]*)"|'([^']*)'|[^;\s]+)\s*$/i.exec(param);
+        if (match === null)
+            continue;
+        const value = match[2] ?? match[3] ?? match[1] ?? "";
+        const tokens = value.split(/\s+/);
+        if (tokens.includes(LDP_INBOX) || tokens.includes("inbox"))
+            return true;
+    }
+    return false;
+}
+/** Split a link-value parameter string on top-level `;`, respecting quotes. */
+function splitLinkParams(params) {
+    const parts = [];
+    let inQuotes = false;
+    let current = "";
+    for (let i = 0; i < params.length; i++) {
+        const char = params[i];
+        if (char === '"' && params[i - 1] !== "\\") {
+            inQuotes = !inQuotes;
+        }
+        if (char === ";" && !inQuotes) {
+            parts.push(current);
+            current = "";
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current.trim() !== "")
+        parts.push(current);
+    return parts;
+}
+//# sourceMappingURL=discovery.js.map

package/dist/discovery.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `@dwk/ldn` — Linked Data Notifications (W3C LDN) primitives.
+ *
+ * @remarks
+ * Cross-standard reusable library: it implements the three LDN roles —
+ * **discovery** (advertise / find an inbox via `ldp:inbox`), **receiver**
+ * (validate a posted RDF notification), and **consumer** (read an inbox
+ * listing) — as plain-data functions over `@dwk/rdf`'s flat `StoredQuad`
+ * representation. It carries no Cloudflare bindings, no transport, and **no
+ * Solid/WAC assumptions**, so the same primitives back the `@dwk/solid-pod`
+ * inbox and the `@dwk/activitypub` inbox without either leaking into the other.
+ * Authorization, dedup, and storage stay the caller's concern.
+ *
+ * @see {@link https://www.w3.org/TR/ldn/ | W3C Linked Data Notifications}
+ * @see spec/packages/ldn.md
+ * @packageDocumentation
+ */
+export { LDP_NAMESPACE, LDP_INBOX, LDP_CONTAINS, LDP_CONSTRAINED_BY, LDP_CONTAINER, LDP_RESOURCE, RDF_TYPE, } from "./vocab";
+export { inboxLinkHeader, inboxTriple, constrainedByLinkHeader, discoverInboxIris, parseInboxLinks, } from "./discovery";
+export { parseNotification, acceptedContentTypes, acceptPostHeader, NotificationProblem, type NotificationProblemCode, type ParsedNotification, type ParseNotificationOptions, } from "./notification";
+export { inboxListingQuads, listInboxMembers } from "./listing";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACL,aAAa,EACb,SAAS,EACT,YAAY,EACZ,kBAAkB,EAClB,aAAa,EACb,YAAY,EACZ,QAAQ,GACT,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,eAAe,EACf,WAAW,EACX,uBAAuB,EACvB,iBAAiB,EACjB,eAAe,GAChB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,EAChB,mBAAmB,EACnB,KAAK,uBAAuB,EAC5B,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,GAC9B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,22 @@
+/**
+ * `@dwk/ldn` — Linked Data Notifications (W3C LDN) primitives.
+ *
+ * @remarks
+ * Cross-standard reusable library: it implements the three LDN roles —
+ * **discovery** (advertise / find an inbox via `ldp:inbox`), **receiver**
+ * (validate a posted RDF notification), and **consumer** (read an inbox
+ * listing) — as plain-data functions over `@dwk/rdf`'s flat `StoredQuad`
+ * representation. It carries no Cloudflare bindings, no transport, and **no
+ * Solid/WAC assumptions**, so the same primitives back the `@dwk/solid-pod`
+ * inbox and the `@dwk/activitypub` inbox without either leaking into the other.
+ * Authorization, dedup, and storage stay the caller's concern.
+ *
+ * @see {@link https://www.w3.org/TR/ldn/ | W3C Linked Data Notifications}
+ * @see spec/packages/ldn.md
+ * @packageDocumentation
+ */
+export { LDP_NAMESPACE, LDP_INBOX, LDP_CONTAINS, LDP_CONSTRAINED_BY, LDP_CONTAINER, LDP_RESOURCE, RDF_TYPE, } from "./vocab";
+export { inboxLinkHeader, inboxTriple, constrainedByLinkHeader, discoverInboxIris, parseInboxLinks, } from "./discovery";
+export { parseNotification, acceptedContentTypes, acceptPostHeader, NotificationProblem, } from "./notification";
+export { inboxListingQuads, listInboxMembers } from "./listing";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACL,aAAa,EACb,SAAS,EACT,YAAY,EACZ,kBAAkB,EAClB,aAAa,EACb,YAAY,EACZ,QAAQ,GACT,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,eAAe,EACf,WAAW,EACX,uBAAuB,EACvB,iBAAiB,EACjB,eAAe,GAChB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,EAChB,mBAAmB,GAIpB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC"}

package/dist/listing.d.ts

@@ -0,0 +1,24 @@
+/**
+ * LDN consumer — inbox listing.
+ *
+ * A consumer `GET`s an inbox and reads the contained notification IRIs. The
+ * inbox is an `ldp:Container` whose members are linked with `ldp:contains`;
+ * {@link inboxListingQuads} builds exactly those triples in the flat
+ * `StoredQuad` shape so a caller can serialize them with `@dwk/rdf`, and
+ * {@link listInboxMembers} reads them back out of a fetched inbox graph.
+ */
+import type { StoredQuad } from "@dwk/rdf";
+/**
+ * Build the triples describing an inbox listing: `<inboxIri> a ldp:Container`
+ * plus one `<inboxIri> ldp:contains <member>` per notification. Members are
+ * de-duplicated, preserving first-seen order.
+ */
+export declare function inboxListingQuads(inboxIri: string, memberIris: Iterable<string>): StoredQuad[];
+/**
+ * Read the notification IRIs an inbox graph contains via `ldp:contains`. When
+ * `inboxIri` is given, only that container's members are returned; otherwise
+ * every `ldp:contains` object is. Only named-node objects count. Results are
+ * de-duplicated, preserving first-seen order.
+ */
+export declare function listInboxMembers(quads: readonly StoredQuad[], inboxIri?: string): string[];
+//# sourceMappingURL=listing.d.ts.map

package/dist/listing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listing.d.ts","sourceRoot":"","sources":["../src/listing.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAU3C;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,GAC3B,UAAU,EAAE,CAsBd;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,EAAE,CASV"}

package/dist/listing.js

@@ -0,0 +1,63 @@
+/**
+ * LDN consumer — inbox listing.
+ *
+ * A consumer `GET`s an inbox and reads the contained notification IRIs. The
+ * inbox is an `ldp:Container` whose members are linked with `ldp:contains`;
+ * {@link inboxListingQuads} builds exactly those triples in the flat
+ * `StoredQuad` shape so a caller can serialize them with `@dwk/rdf`, and
+ * {@link listInboxMembers} reads them back out of a fetched inbox graph.
+ */
+import { LDP_CONTAINS, LDP_CONTAINER, RDF_TYPE } from "./vocab";
+const DEFAULT_GRAPH = { termType: "DefaultGraph", value: "" };
+function namedNode(value) {
+    return { termType: "NamedNode", value };
+}
+/**
+ * Build the triples describing an inbox listing: `<inboxIri> a ldp:Container`
+ * plus one `<inboxIri> ldp:contains <member>` per notification. Members are
+ * de-duplicated, preserving first-seen order.
+ */
+export function inboxListingQuads(inboxIri, memberIris) {
+    const subject = namedNode(inboxIri);
+    const quads = [
+        {
+            subject,
+            predicate: namedNode(RDF_TYPE),
+            object: namedNode(LDP_CONTAINER),
+            graph: DEFAULT_GRAPH,
+        },
+    ];
+    const seen = new Set();
+    for (const member of memberIris) {
+        if (seen.has(member))
+            continue;
+        seen.add(member);
+        quads.push({
+            subject,
+            predicate: namedNode(LDP_CONTAINS),
+            object: namedNode(member),
+            graph: DEFAULT_GRAPH,
+        });
+    }
+    return quads;
+}
+/**
+ * Read the notification IRIs an inbox graph contains via `ldp:contains`. When
+ * `inboxIri` is given, only that container's members are returned; otherwise
+ * every `ldp:contains` object is. Only named-node objects count. Results are
+ * de-duplicated, preserving first-seen order.
+ */
+export function listInboxMembers(quads, inboxIri) {
+    const found = new Set();
+    for (const quad of quads) {
+        if (quad.predicate.value !== LDP_CONTAINS)
+            continue;
+        if (quad.object.termType !== "NamedNode")
+            continue;
+        if (inboxIri !== undefined && quad.subject.value !== inboxIri)
+            continue;
+        found.add(quad.object.value);
+    }
+    return [...found];
+}
+//# sourceMappingURL=listing.js.map

package/dist/listing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"listing.js","sourceRoot":"","sources":["../src/listing.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEhE,MAAM,aAAa,GAAG,EAAE,QAAQ,EAAE,cAAc,EAAE,KAAK,EAAE,EAAE,EAAW,CAAC;AAEvE,SAAS,SAAS,CAAC,KAAa;IAC9B,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;AAC1C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAC/B,QAAgB,EAChB,UAA4B;IAE5B,MAAM,OAAO,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;IACpC,MAAM,KAAK,GAAiB;QAC1B;YACE,OAAO;YACP,SAAS,EAAE,SAAS,CAAC,QAAQ,CAAC;YAC9B,MAAM,EAAE,SAAS,CAAC,aAAa,CAAC;YAChC,KAAK,EAAE,aAAa;SACrB;KACF,CAAC;IACF,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,KAAK,MAAM,MAAM,IAAI,UAAU,EAAE,CAAC;QAChC,IAAI,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC;YAAE,SAAS;QAC/B,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACjB,KAAK,CAAC,IAAI,CAAC;YACT,OAAO;YACP,SAAS,EAAE,SAAS,CAAC,YAAY,CAAC;YAClC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC;YACzB,KAAK,EAAE,aAAa;SACrB,CAAC,CAAC;IACL,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAC9B,KAA4B,EAC5B,QAAiB;IAEjB,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;IAChC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,KAAK,YAAY;YAAE,SAAS;QACpD,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,KAAK,WAAW;YAAE,SAAS;QACnD,IAAI,QAAQ,KAAK,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,KAAK,QAAQ;YAAE,SAAS;QACxE,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC;AACpB,CAAC"}

package/dist/notification.d.ts

@@ -0,0 +1,66 @@
+/**
+ * LDN receiver — notification validation.
+ *
+ * An LDN receiver accepts a `POST` of an RDF notification to an inbox. The body
+ * MUST be a supported RDF serialization (LDN mandates JSON-LD; this also accepts
+ * the Turtle family `@dwk/rdf` supports) and MUST parse. This module classifies
+ * the two rejection cases an inbox owner needs to map to a status code —
+ * `unsupported_media_type` (415) and `malformed` (400) — and otherwise returns
+ * the parsed triples in the flat, storage-friendly `StoredQuad` shape. It stays
+ * protocol-agnostic: authorization, dedup, and storage are the caller's concern.
+ *
+ * Per LDN §3.3.1, a receiver SHOULD advertise the content types it accepts via
+ * an `Accept-Post` header on `OPTIONS`. {@link acceptedContentTypes} and
+ * {@link acceptPostHeader} build that advertisement from the same media-type
+ * table {@link parseNotification} validates against, so the two cannot drift.
+ */
+import { type RdfFormat, type StoredQuad } from "@dwk/rdf";
+/** Why a notification body was rejected. */
+export type NotificationProblemCode = "unsupported_media_type" | "malformed";
+/**
+ * A rejected notification body, carrying the HTTP status an LDN receiver should
+ * answer: `415` for a non-RDF / unknown media type, `400` for an RDF media type
+ * whose body does not parse.
+ */
+export declare class NotificationProblem extends Error {
+    readonly code: NotificationProblemCode;
+    readonly status: 415 | 400;
+    constructor(code: NotificationProblemCode, message: string);
+}
+/** A validated notification: its triples plus the RDF format it arrived in. */
+export interface ParsedNotification {
+    readonly quads: StoredQuad[];
+    readonly mediaType: string;
+    readonly format: RdfFormat;
+}
+/** Options for {@link parseNotification}. */
+export interface ParseNotificationOptions {
+    /** Base IRI used to resolve relative IRIs in the notification body. */
+    readonly baseIRI?: string;
+}
+/**
+ * Validate and parse an LDN notification body. Throws a {@link NotificationProblem}
+ * when the `Content-Type` is missing / not a supported RDF serialization (415),
+ * or when the body fails to parse (400). On success the triples are returned as
+ * {@link StoredQuad}s ready to persist.
+ *
+ * A well-formed body that yields zero triples (an empty JSON-LD `@graph`, a bare
+ * `@context`, a Turtle document of only prefix declarations) is **accepted**:
+ * LDN §3.2 does not require a notification to carry at least one triple, so this
+ * returns an empty `quads` array rather than rejecting it as malformed.
+ */
+export declare function parseNotification(body: string, contentType: string | null, options?: ParseNotificationOptions): Promise<ParsedNotification>;
+/**
+ * The RDF media types {@link parseNotification} accepts, in registry order — the
+ * value set an LDN receiver should advertise so senders pick a supported
+ * serialization. Derived from `@dwk/rdf`'s `MEDIA_TYPE_FORMATS`, the same table
+ * parsing validates against, so the advertisement and the validator never drift.
+ */
+export declare function acceptedContentTypes(): string[];
+/**
+ * Build the `Accept-Post` header value (LDN §3.3.1) an LDN receiver should
+ * answer on `OPTIONS`, advertising every content type {@link parseNotification}
+ * accepts as a comma-separated list.
+ */
+export declare function acceptPostHeader(): string;
+//# sourceMappingURL=notification.d.ts.map

package/dist/notification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification.d.ts","sourceRoot":"","sources":["../src/notification.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAKL,KAAK,SAAS,EACd,KAAK,UAAU,EAChB,MAAM,UAAU,CAAC;AAElB,4CAA4C;AAC5C,MAAM,MAAM,uBAAuB,GAAG,wBAAwB,GAAG,WAAW,CAAC;AAE7E;;;;GAIG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,QAAQ,CAAC,IAAI,EAAE,uBAAuB,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC;gBAEf,IAAI,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM;CAM3D;AAED,+EAA+E;AAC/E,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,KAAK,EAAE,UAAU,EAAE,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;CAC5B;AAED,6CAA6C;AAC7C,MAAM,WAAW,wBAAwB;IACvC,uEAAuE;IACvE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,kBAAkB,CAAC,CA+B7B;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAE/C;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC"}

package/dist/notification.js

@@ -0,0 +1,82 @@
+/**
+ * LDN receiver — notification validation.
+ *
+ * An LDN receiver accepts a `POST` of an RDF notification to an inbox. The body
+ * MUST be a supported RDF serialization (LDN mandates JSON-LD; this also accepts
+ * the Turtle family `@dwk/rdf` supports) and MUST parse. This module classifies
+ * the two rejection cases an inbox owner needs to map to a status code —
+ * `unsupported_media_type` (415) and `malformed` (400) — and otherwise returns
+ * the parsed triples in the flat, storage-friendly `StoredQuad` shape. It stays
+ * protocol-agnostic: authorization, dedup, and storage are the caller's concern.
+ *
+ * Per LDN §3.3.1, a receiver SHOULD advertise the content types it accepts via
+ * an `Accept-Post` header on `OPTIONS`. {@link acceptedContentTypes} and
+ * {@link acceptPostHeader} build that advertisement from the same media-type
+ * table {@link parseNotification} validates against, so the two cannot drift.
+ */
+import { parse as parseRdf, formatForMediaType, quadToStored, MEDIA_TYPE_FORMATS, } from "@dwk/rdf";
+/**
+ * A rejected notification body, carrying the HTTP status an LDN receiver should
+ * answer: `415` for a non-RDF / unknown media type, `400` for an RDF media type
+ * whose body does not parse.
+ */
+export class NotificationProblem extends Error {
+    code;
+    status;
+    constructor(code, message) {
+        super(message);
+        this.name = "NotificationProblem";
+        this.code = code;
+        this.status = code === "unsupported_media_type" ? 415 : 400;
+    }
+}
+/**
+ * Validate and parse an LDN notification body. Throws a {@link NotificationProblem}
+ * when the `Content-Type` is missing / not a supported RDF serialization (415),
+ * or when the body fails to parse (400). On success the triples are returned as
+ * {@link StoredQuad}s ready to persist.
+ *
+ * A well-formed body that yields zero triples (an empty JSON-LD `@graph`, a bare
+ * `@context`, a Turtle document of only prefix declarations) is **accepted**:
+ * LDN §3.2 does not require a notification to carry at least one triple, so this
+ * returns an empty `quads` array rather than rejecting it as malformed.
+ */
+export async function parseNotification(body, contentType, options = {}) {
+    // Resolve the clean media type once (no parameters/casing) and reuse it for
+    // both format lookup and parsing, consistent with the rest of the codebase.
+    const mediaType = contentType
+        ? (contentType.split(";")[0]?.trim().toLowerCase() ?? "")
+        : "";
+    const format = mediaType ? formatForMediaType(mediaType) : undefined;
+    if (!format) {
+        throw new NotificationProblem("unsupported_media_type", `@dwk/ldn: notification media type "${contentType ?? ""}" is not a ` +
+            `supported RDF serialization`);
+    }
+    let quads;
+    try {
+        quads = await parseRdf(body, mediaType, options.baseIRI ? { baseIRI: options.baseIRI } : {});
+    }
+    catch (error) {
+        throw new NotificationProblem("malformed", `@dwk/ldn: notification body is not valid ${format}: ` +
+            `${error instanceof Error ? error.message : String(error)}`);
+    }
+    return { quads: quads.map(quadToStored), mediaType, format };
+}
+/**
+ * The RDF media types {@link parseNotification} accepts, in registry order — the
+ * value set an LDN receiver should advertise so senders pick a supported
+ * serialization. Derived from `@dwk/rdf`'s `MEDIA_TYPE_FORMATS`, the same table
+ * parsing validates against, so the advertisement and the validator never drift.
+ */
+export function acceptedContentTypes() {
+    return Object.keys(MEDIA_TYPE_FORMATS);
+}
+/**
+ * Build the `Accept-Post` header value (LDN §3.3.1) an LDN receiver should
+ * answer on `OPTIONS`, advertising every content type {@link parseNotification}
+ * accepts as a comma-separated list.
+ */
+export function acceptPostHeader() {
+    return acceptedContentTypes().join(", ");
+}
+//# sourceMappingURL=notification.js.map

package/dist/notification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification.js","sourceRoot":"","sources":["../src/notification.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,KAAK,IAAI,QAAQ,EACjB,kBAAkB,EAClB,YAAY,EACZ,kBAAkB,GAGnB,MAAM,UAAU,CAAC;AAKlB;;;;GAIG;AACH,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IACnC,IAAI,CAA0B;IAC9B,MAAM,CAAY;IAE3B,YAAY,IAA6B,EAAE,OAAe;QACxD,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;QAClC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,MAAM,GAAG,IAAI,KAAK,wBAAwB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;IAC9D,CAAC;CACF;AAeD;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,IAAY,EACZ,WAA0B,EAC1B,UAAoC,EAAE;IAEtC,4EAA4E;IAC5E,4EAA4E;IAC5E,MAAM,SAAS,GAAG,WAAW;QAC3B,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,WAAW,EAAE,IAAI,EAAE,CAAC;QACzD,CAAC,CAAC,EAAE,CAAC;IACP,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACrE,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,IAAI,mBAAmB,CAC3B,wBAAwB,EACxB,sCAAsC,WAAW,IAAI,EAAE,aAAa;YAClE,6BAA6B,CAChC,CAAC;IACJ,CAAC;IAED,IAAI,KAAK,CAAC;IACV,IAAI,CAAC;QACH,KAAK,GAAG,MAAM,QAAQ,CACpB,IAAI,EACJ,SAAS,EACT,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CACpD,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,mBAAmB,CAC3B,WAAW,EACX,4CAA4C,MAAM,IAAI;YACpD,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAC9D,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC;AAC/D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;AACzC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO,oBAAoB,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC3C,CAAC"}

package/dist/vocab.d.ts

@@ -0,0 +1,22 @@
+/**
+ * LDP / RDF vocabulary terms used by Linked Data Notifications.
+ *
+ * LDN layers a single property — `ldp:inbox` — and the LDP container model onto
+ * RDF; these constants are the full IRIs so callers never hard-code a typo'd
+ * namespace.
+ */
+/** The LDP namespace IRI. */
+export declare const LDP_NAMESPACE = "http://www.w3.org/ns/ldp#";
+/** `ldp:inbox` — the property a resource uses to advertise its inbox. */
+export declare const LDP_INBOX = "http://www.w3.org/ns/ldp#inbox";
+/** `ldp:contains` — links a container to each of its members. */
+export declare const LDP_CONTAINS = "http://www.w3.org/ns/ldp#contains";
+/** `ldp:constrainedBy` — points at the constraints a resource imposes (LDN §5.1). */
+export declare const LDP_CONSTRAINED_BY = "http://www.w3.org/ns/ldp#constrainedBy";
+/** `ldp:Container` — the type of an inbox (a container of notifications). */
+export declare const LDP_CONTAINER = "http://www.w3.org/ns/ldp#Container";
+/** `ldp:Resource` — the LDP resource type. */
+export declare const LDP_RESOURCE = "http://www.w3.org/ns/ldp#Resource";
+/** `rdf:type` — used to assert the inbox container's type in a listing. */
+export declare const RDF_TYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+//# sourceMappingURL=vocab.d.ts.map

package/dist/vocab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vocab.d.ts","sourceRoot":"","sources":["../src/vocab.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,6BAA6B;AAC7B,eAAO,MAAM,aAAa,8BAA8B,CAAC;AAEzD,yEAAyE;AACzE,eAAO,MAAM,SAAS,mCAA0B,CAAC;AAEjD,iEAAiE;AACjE,eAAO,MAAM,YAAY,sCAA6B,CAAC;AAEvD,qFAAqF;AACrF,eAAO,MAAM,kBAAkB,2CAAkC,CAAC;AAElE,6EAA6E;AAC7E,eAAO,MAAM,aAAa,uCAA8B,CAAC;AAEzD,8CAA8C;AAC9C,eAAO,MAAM,YAAY,sCAA6B,CAAC;AAEvD,2EAA2E;AAC3E,eAAO,MAAM,QAAQ,oDAAoD,CAAC"}

package/dist/vocab.js

@@ -0,0 +1,22 @@
+/**
+ * LDP / RDF vocabulary terms used by Linked Data Notifications.
+ *
+ * LDN layers a single property — `ldp:inbox` — and the LDP container model onto
+ * RDF; these constants are the full IRIs so callers never hard-code a typo'd
+ * namespace.
+ */
+/** The LDP namespace IRI. */
+export const LDP_NAMESPACE = "http://www.w3.org/ns/ldp#";
+/** `ldp:inbox` — the property a resource uses to advertise its inbox. */
+export const LDP_INBOX = `${LDP_NAMESPACE}inbox`;
+/** `ldp:contains` — links a container to each of its members. */
+export const LDP_CONTAINS = `${LDP_NAMESPACE}contains`;
+/** `ldp:constrainedBy` — points at the constraints a resource imposes (LDN §5.1). */
+export const LDP_CONSTRAINED_BY = `${LDP_NAMESPACE}constrainedBy`;
+/** `ldp:Container` — the type of an inbox (a container of notifications). */
+export const LDP_CONTAINER = `${LDP_NAMESPACE}Container`;
+/** `ldp:Resource` — the LDP resource type. */
+export const LDP_RESOURCE = `${LDP_NAMESPACE}Resource`;
+/** `rdf:type` — used to assert the inbox container's type in a listing. */
+export const RDF_TYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+//# sourceMappingURL=vocab.js.map

package/dist/vocab.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vocab.js","sourceRoot":"","sources":["../src/vocab.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,6BAA6B;AAC7B,MAAM,CAAC,MAAM,aAAa,GAAG,2BAA2B,CAAC;AAEzD,yEAAyE;AACzE,MAAM,CAAC,MAAM,SAAS,GAAG,GAAG,aAAa,OAAO,CAAC;AAEjD,iEAAiE;AACjE,MAAM,CAAC,MAAM,YAAY,GAAG,GAAG,aAAa,UAAU,CAAC;AAEvD,qFAAqF;AACrF,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,aAAa,eAAe,CAAC;AAElE,6EAA6E;AAC7E,MAAM,CAAC,MAAM,aAAa,GAAG,GAAG,aAAa,WAAW,CAAC;AAEzD,8CAA8C;AAC9C,MAAM,CAAC,MAAM,YAAY,GAAG,GAAG,aAAa,UAAU,CAAC;AAEvD,2EAA2E;AAC3E,MAAM,CAAC,MAAM,QAAQ,GAAG,iDAAiD,CAAC"}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@dwk/ldn",
+  "version": "0.1.0-beta.0",
+  "description": "Linked Data Notifications (W3C LDN) primitives: inbox discovery, notification validation, and listing. RDF-only, protocol-agnostic.",
+  "keywords": [
+    "linked-data-notifications",
+    "ldn",
+    "inbox",
+    "rdf",
+    "solid",
+    "activitypub"
+  ],
+  "type": "module",
+  "license": "ISC",
+  "author": "David W. Keith <me@dwk.io>",
+  "homepage": "https://github.com/davidwkeith/workers/tree/main/packages/ldn#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/davidwkeith/workers.git",
+    "directory": "packages/ldn"
+  },
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./discovery": {
+      "types": "./dist/discovery.d.ts",
+      "import": "./dist/discovery.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@dwk/rdf": "0.1.0-beta.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist"
+  }
+}

package/src/discovery.ts

@@ -0,0 +1,166 @@
+/**
+ * LDN inbox discovery — both sides of the wire.
+ *
+ * A target resource advertises its inbox so a sender can find it. LDN allows the
+ * advertisement to travel either in an HTTP `Link` header or as an `ldp:inbox`
+ * triple in the resource's RDF body, so this module covers building the header
+ * (and triple) on the producer side and parsing both forms on the consumer side.
+ *
+ * It depends on `@dwk/rdf` for *types only* (erased at build), so it carries no
+ * RDF-parser runtime. It is re-exported from the package root and also reachable
+ * directly as `@dwk/ldn/discovery`, the n3-free entry point a binding-bound
+ * consumer (e.g. a Workers runtime) imports to advertise an inbox without
+ * pulling in the notification parser.
+ */
+
+import type { StoredQuad } from "@dwk/rdf";
+
+import { LDP_INBOX, LDP_CONSTRAINED_BY } from "./vocab";
+
+const DEFAULT_GRAPH = { termType: "DefaultGraph", value: "" } as const;
+
+/**
+ * Build the `Link` header value advertising `inboxIri` as the resource's inbox:
+ * `<inboxIri>; rel="http://www.w3.org/ns/ldp#inbox"`. Join it with any other
+ * link-values using `, ` to form a complete header.
+ */
+export function inboxLinkHeader(inboxIri: string): string {
+  return `<${inboxIri}>; rel="${LDP_INBOX}"`;
+}
+
+/**
+ * Build the `Link` header value advertising `constraintsIri` as the constraints
+ * a resource imposes: `<constraintsIri>; rel="http://www.w3.org/ns/ldp#constrainedBy"`.
+ * LDN §5.1 (and LDP) lets a receiver point senders at a document describing the
+ * constraints it enforces — the media types it accepts, whether it requires a
+ * non-empty graph, and so on. Join it with any other link-values using `, `.
+ */
+export function constrainedByLinkHeader(constraintsIri: string): string {
+  return `<${constraintsIri}>; rel="${LDP_CONSTRAINED_BY}"`;
+}
+
+/**
+ * Build the `<subjectIri> ldp:inbox <inboxIri>` triple that advertises the inbox
+ * inside a resource's RDF body (the alternative to the `Link` header).
+ */
+export function inboxTriple(subjectIri: string, inboxIri: string): StoredQuad {
+  return {
+    subject: { termType: "NamedNode", value: subjectIri },
+    predicate: { termType: "NamedNode", value: LDP_INBOX },
+    object: { termType: "NamedNode", value: inboxIri },
+    graph: DEFAULT_GRAPH,
+  };
+}
+
+/**
+ * Extract the inbox IRIs a graph advertises via `ldp:inbox`. When `subjectIri`
+ * is given, only triples with that subject are considered (the usual case: "what
+ * is _this_ resource's inbox?"); otherwise every `ldp:inbox` object is returned.
+ * Only named-node objects count — a literal `ldp:inbox` is not a dereferenceable
+ * inbox. Results are de-duplicated, preserving first-seen order.
+ */
+export function discoverInboxIris(
+  quads: readonly StoredQuad[],
+  subjectIri?: string,
+): string[] {
+  const found = new Set<string>();
+  for (const quad of quads) {
+    if (quad.predicate.value !== LDP_INBOX) continue;
+    if (quad.object.termType !== "NamedNode") continue;
+    if (subjectIri !== undefined && quad.subject.value !== subjectIri) continue;
+    found.add(quad.object.value);
+  }
+  return [...found];
+}
+
+/**
+ * Parse the inbox IRIs advertised by an HTTP `Link` header. A link-value counts
+ * when its `rel` token list includes the full `ldp:inbox` IRI (LDN's canonical
+ * form) or the bare `inbox` token. Returns de-duplicated, first-seen-order IRIs;
+ * an absent or malformed header yields an empty list.
+ */
+export function parseInboxLinks(linkHeader: string | null): string[] {
+  if (!linkHeader) return [];
+  const found = new Set<string>();
+  for (const entry of splitLinkValues(linkHeader)) {
+    const start = entry.indexOf("<");
+    const end = entry.indexOf(">", start + 1);
+    if (start === -1 || end === -1) continue;
+    const uri = entry.slice(start + 1, end).trim();
+    if (uri.length === 0) continue;
+    if (linkEntryRelIsInbox(entry.slice(end + 1))) found.add(uri);
+  }
+  return [...found];
+}
+
+/**
+ * Split a `Link` header into its individual link-values on top-level commas,
+ * tracking both quoted parameter values and `<…>` URI-references so a comma
+ * inside either never splits an entry (RFC 8288). A simple `,`-followed-by-`<`
+ * regex would mis-split a quoted parameter such as `title="a, <b>"`.
+ */
+function splitLinkValues(header: string): string[] {
+  const values: string[] = [];
+  let inQuotes = false;
+  let inBrackets = false;
+  let current = "";
+  for (let i = 0; i < header.length; i++) {
+    const char = header[i] as string;
+    if (char === '"' && header[i - 1] !== "\\") {
+      inQuotes = !inQuotes;
+    } else if (char === "<" && !inQuotes) {
+      inBrackets = true;
+    } else if (char === ">" && !inQuotes) {
+      inBrackets = false;
+    }
+    if (char === "," && !inQuotes && !inBrackets) {
+      values.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim() !== "") values.push(current);
+  return values;
+}
+
+/**
+ * Whether a link-value's parameter string declares `rel` naming the inbox. `rel`
+ * is a space-separated token list, so `rel="http://www.w3.org/ns/ldp#inbox"` and
+ * `rel="inbox alternate"` both count. Parameters are split on top-level `;`
+ * (respecting quotes) so a `rel=...` substring inside another quoted parameter
+ * value is not mistaken for the rel parameter.
+ */
+function linkEntryRelIsInbox(params: string): boolean {
+  for (const param of splitLinkParams(params)) {
+    const match = /^\s*rel\s*=\s*("([^"]*)"|'([^']*)'|[^;\s]+)\s*$/i.exec(
+      param,
+    );
+    if (match === null) continue;
+    const value = match[2] ?? match[3] ?? match[1] ?? "";
+    const tokens = value.split(/\s+/);
+    if (tokens.includes(LDP_INBOX) || tokens.includes("inbox")) return true;
+  }
+  return false;
+}
+
+/** Split a link-value parameter string on top-level `;`, respecting quotes. */
+function splitLinkParams(params: string): string[] {
+  const parts: string[] = [];
+  let inQuotes = false;
+  let current = "";
+  for (let i = 0; i < params.length; i++) {
+    const char = params[i] as string;
+    if (char === '"' && params[i - 1] !== "\\") {
+      inQuotes = !inQuotes;
+    }
+    if (char === ";" && !inQuotes) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim() !== "") parts.push(current);
+  return parts;
+}

package/src/index.ts

@@ -0,0 +1,47 @@
+/**
+ * `@dwk/ldn` — Linked Data Notifications (W3C LDN) primitives.
+ *
+ * @remarks
+ * Cross-standard reusable library: it implements the three LDN roles —
+ * **discovery** (advertise / find an inbox via `ldp:inbox`), **receiver**
+ * (validate a posted RDF notification), and **consumer** (read an inbox
+ * listing) — as plain-data functions over `@dwk/rdf`'s flat `StoredQuad`
+ * representation. It carries no Cloudflare bindings, no transport, and **no
+ * Solid/WAC assumptions**, so the same primitives back the `@dwk/solid-pod`
+ * inbox and the `@dwk/activitypub` inbox without either leaking into the other.
+ * Authorization, dedup, and storage stay the caller's concern.
+ *
+ * @see {@link https://www.w3.org/TR/ldn/ | W3C Linked Data Notifications}
+ * @see spec/packages/ldn.md
+ * @packageDocumentation
+ */
+
+export {
+  LDP_NAMESPACE,
+  LDP_INBOX,
+  LDP_CONTAINS,
+  LDP_CONSTRAINED_BY,
+  LDP_CONTAINER,
+  LDP_RESOURCE,
+  RDF_TYPE,
+} from "./vocab";
+
+export {
+  inboxLinkHeader,
+  inboxTriple,
+  constrainedByLinkHeader,
+  discoverInboxIris,
+  parseInboxLinks,
+} from "./discovery";
+
+export {
+  parseNotification,
+  acceptedContentTypes,
+  acceptPostHeader,
+  NotificationProblem,
+  type NotificationProblemCode,
+  type ParsedNotification,
+  type ParseNotificationOptions,
+} from "./notification";
+
+export { inboxListingQuads, listInboxMembers } from "./listing";

package/src/listing.ts

@@ -0,0 +1,71 @@
+/**
+ * LDN consumer — inbox listing.
+ *
+ * A consumer `GET`s an inbox and reads the contained notification IRIs. The
+ * inbox is an `ldp:Container` whose members are linked with `ldp:contains`;
+ * {@link inboxListingQuads} builds exactly those triples in the flat
+ * `StoredQuad` shape so a caller can serialize them with `@dwk/rdf`, and
+ * {@link listInboxMembers} reads them back out of a fetched inbox graph.
+ */
+
+import type { StoredQuad } from "@dwk/rdf";
+
+import { LDP_CONTAINS, LDP_CONTAINER, RDF_TYPE } from "./vocab";
+
+const DEFAULT_GRAPH = { termType: "DefaultGraph", value: "" } as const;
+
+function namedNode(value: string): StoredQuad["object"] {
+  return { termType: "NamedNode", value };
+}
+
+/**
+ * Build the triples describing an inbox listing: `<inboxIri> a ldp:Container`
+ * plus one `<inboxIri> ldp:contains <member>` per notification. Members are
+ * de-duplicated, preserving first-seen order.
+ */
+export function inboxListingQuads(
+  inboxIri: string,
+  memberIris: Iterable<string>,
+): StoredQuad[] {
+  const subject = namedNode(inboxIri);
+  const quads: StoredQuad[] = [
+    {
+      subject,
+      predicate: namedNode(RDF_TYPE),
+      object: namedNode(LDP_CONTAINER),
+      graph: DEFAULT_GRAPH,
+    },
+  ];
+  const seen = new Set<string>();
+  for (const member of memberIris) {
+    if (seen.has(member)) continue;
+    seen.add(member);
+    quads.push({
+      subject,
+      predicate: namedNode(LDP_CONTAINS),
+      object: namedNode(member),
+      graph: DEFAULT_GRAPH,
+    });
+  }
+  return quads;
+}
+
+/**
+ * Read the notification IRIs an inbox graph contains via `ldp:contains`. When
+ * `inboxIri` is given, only that container's members are returned; otherwise
+ * every `ldp:contains` object is. Only named-node objects count. Results are
+ * de-duplicated, preserving first-seen order.
+ */
+export function listInboxMembers(
+  quads: readonly StoredQuad[],
+  inboxIri?: string,
+): string[] {
+  const found = new Set<string>();
+  for (const quad of quads) {
+    if (quad.predicate.value !== LDP_CONTAINS) continue;
+    if (quad.object.termType !== "NamedNode") continue;
+    if (inboxIri !== undefined && quad.subject.value !== inboxIri) continue;
+    found.add(quad.object.value);
+  }
+  return [...found];
+}

package/src/notification.ts

@@ -0,0 +1,125 @@
+/**
+ * LDN receiver — notification validation.
+ *
+ * An LDN receiver accepts a `POST` of an RDF notification to an inbox. The body
+ * MUST be a supported RDF serialization (LDN mandates JSON-LD; this also accepts
+ * the Turtle family `@dwk/rdf` supports) and MUST parse. This module classifies
+ * the two rejection cases an inbox owner needs to map to a status code —
+ * `unsupported_media_type` (415) and `malformed` (400) — and otherwise returns
+ * the parsed triples in the flat, storage-friendly `StoredQuad` shape. It stays
+ * protocol-agnostic: authorization, dedup, and storage are the caller's concern.
+ *
+ * Per LDN §3.3.1, a receiver SHOULD advertise the content types it accepts via
+ * an `Accept-Post` header on `OPTIONS`. {@link acceptedContentTypes} and
+ * {@link acceptPostHeader} build that advertisement from the same media-type
+ * table {@link parseNotification} validates against, so the two cannot drift.
+ */
+
+import {
+  parse as parseRdf,
+  formatForMediaType,
+  quadToStored,
+  MEDIA_TYPE_FORMATS,
+  type RdfFormat,
+  type StoredQuad,
+} from "@dwk/rdf";
+
+/** Why a notification body was rejected. */
+export type NotificationProblemCode = "unsupported_media_type" | "malformed";
+
+/**
+ * A rejected notification body, carrying the HTTP status an LDN receiver should
+ * answer: `415` for a non-RDF / unknown media type, `400` for an RDF media type
+ * whose body does not parse.
+ */
+export class NotificationProblem extends Error {
+  readonly code: NotificationProblemCode;
+  readonly status: 415 | 400;
+
+  constructor(code: NotificationProblemCode, message: string) {
+    super(message);
+    this.name = "NotificationProblem";
+    this.code = code;
+    this.status = code === "unsupported_media_type" ? 415 : 400;
+  }
+}
+
+/** A validated notification: its triples plus the RDF format it arrived in. */
+export interface ParsedNotification {
+  readonly quads: StoredQuad[];
+  readonly mediaType: string;
+  readonly format: RdfFormat;
+}
+
+/** Options for {@link parseNotification}. */
+export interface ParseNotificationOptions {
+  /** Base IRI used to resolve relative IRIs in the notification body. */
+  readonly baseIRI?: string;
+}
+
+/**
+ * Validate and parse an LDN notification body. Throws a {@link NotificationProblem}
+ * when the `Content-Type` is missing / not a supported RDF serialization (415),
+ * or when the body fails to parse (400). On success the triples are returned as
+ * {@link StoredQuad}s ready to persist.
+ *
+ * A well-formed body that yields zero triples (an empty JSON-LD `@graph`, a bare
+ * `@context`, a Turtle document of only prefix declarations) is **accepted**:
+ * LDN §3.2 does not require a notification to carry at least one triple, so this
+ * returns an empty `quads` array rather than rejecting it as malformed.
+ */
+export async function parseNotification(
+  body: string,
+  contentType: string | null,
+  options: ParseNotificationOptions = {},
+): Promise<ParsedNotification> {
+  // Resolve the clean media type once (no parameters/casing) and reuse it for
+  // both format lookup and parsing, consistent with the rest of the codebase.
+  const mediaType = contentType
+    ? (contentType.split(";")[0]?.trim().toLowerCase() ?? "")
+    : "";
+  const format = mediaType ? formatForMediaType(mediaType) : undefined;
+  if (!format) {
+    throw new NotificationProblem(
+      "unsupported_media_type",
+      `@dwk/ldn: notification media type "${contentType ?? ""}" is not a ` +
+        `supported RDF serialization`,
+    );
+  }
+
+  let quads;
+  try {
+    quads = await parseRdf(
+      body,
+      mediaType,
+      options.baseIRI ? { baseIRI: options.baseIRI } : {},
+    );
+  } catch (error) {
+    throw new NotificationProblem(
+      "malformed",
+      `@dwk/ldn: notification body is not valid ${format}: ` +
+        `${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+
+  return { quads: quads.map(quadToStored), mediaType, format };
+}
+
+/**
+ * The RDF media types {@link parseNotification} accepts, in registry order — the
+ * value set an LDN receiver should advertise so senders pick a supported
+ * serialization. Derived from `@dwk/rdf`'s `MEDIA_TYPE_FORMATS`, the same table
+ * parsing validates against, so the advertisement and the validator never drift.
+ */
+export function acceptedContentTypes(): string[] {
+  return Object.keys(MEDIA_TYPE_FORMATS);
+}
+
+/**
+ * Build the `Accept-Post` header value (LDN §3.3.1) an LDN receiver should
+ * answer on `OPTIONS`, advertising every content type {@link parseNotification}
+ * accepts as a comma-separated list.
+ */
+export function acceptPostHeader(): string {
+  return acceptedContentTypes().join(", ");
+}

package/src/vocab.ts

@@ -0,0 +1,28 @@
+/**
+ * LDP / RDF vocabulary terms used by Linked Data Notifications.
+ *
+ * LDN layers a single property — `ldp:inbox` — and the LDP container model onto
+ * RDF; these constants are the full IRIs so callers never hard-code a typo'd
+ * namespace.
+ */
+
+/** The LDP namespace IRI. */
+export const LDP_NAMESPACE = "http://www.w3.org/ns/ldp#";
+
+/** `ldp:inbox` — the property a resource uses to advertise its inbox. */
+export const LDP_INBOX = `${LDP_NAMESPACE}inbox`;
+
+/** `ldp:contains` — links a container to each of its members. */
+export const LDP_CONTAINS = `${LDP_NAMESPACE}contains`;
+
+/** `ldp:constrainedBy` — points at the constraints a resource imposes (LDN §5.1). */
+export const LDP_CONSTRAINED_BY = `${LDP_NAMESPACE}constrainedBy`;
+
+/** `ldp:Container` — the type of an inbox (a container of notifications). */
+export const LDP_CONTAINER = `${LDP_NAMESPACE}Container`;
+
+/** `ldp:Resource` — the LDP resource type. */
+export const LDP_RESOURCE = `${LDP_NAMESPACE}Resource`;
+
+/** `rdf:type` — used to assert the inbox container's type in a listing. */
+export const RDF_TYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";