@ndes/iiif-images 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,127 @@
-# Temporary Holding Version
+# @ndes/iiif-images
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Enriches SCHEMA-AP-NDE works with the dimensions and sizes of the IIIF image that
+represents them, so a frontend can reserve the right aspect ratio and pick a size
+before the image loads.
+
+It is a quad transform for `@lde/search-indexer`. For each work with a IIIF
+Presentation manifest in `associatedMedia`, it reads the manifest, selects an image,
+reads its image service’s `info.json` if it has one and mints a nested
+`representativeImage`.
+
+## Usage
+
+Declare the fields in your schema module. The `/schema` entry point has no runtime
+dependencies, so a bundled schema module stays self-contained:
+
+```ts
+import {
+  iiifImageTypes,
+  representativeImageField,
+} from '@ndes/iiif-images/schema';
+
+const creativeWork = defineSearchType({
+  name: 'CreativeWork',
+  class: 'https://schema.org/CreativeWork',
+  fields: [representativeImageField /* … */],
+});
+```
+
+Add `iiifImageTypes` to the schema, then attach the transform after any transform
+that repairs IRIs:
+
+```ts
+import { iiifImages } from '@ndes/iiif-images';
+
+const images = iiifImages(schema, { storePath: '/provenance/iiif.sqlite' });
+await images.check();
+
+const transform = images.transformFor(creativeWork);
+const pipeline = await createSearchIndexer(config, {
+  transforms: {
+    CreativeWork: [anyUriToIri(schema), ...(transform ? [transform] : [])],
+  },
+});
+```
+
+`transformFor` answers `undefined` for a root type that does not declare
+`representativeImage` and `associatedMedia`, so a deployment on an older schema loses
+the enrichment rather than the run.
+
+| Option          | Default         | Purpose                                                  |
+| --------------- | --------------- | -------------------------------------------------------- |
+| `storePath`     | required        | SQLite file holding resolved facts between runs          |
+| `fetchesPerRun` | 500             | Manifests, and separately `info.json` documents, per run |
+| `report`        | console warning | Called for each reference whose fetch failed             |
+
+`storePath` has to be on a durable volume. The store is the only place these facts
+live between runs, and with an empty one every image is fetched from the publisher
+again.
+
+## Consuming the field
+
+```json
+{
+  "representativeImage": {
+    "url": "https://example.org/iiif/image/full/max/0/default.jpg",
+    "width": 1335,
+    "height": 2750,
+    "sizes": [
+      {
+        "width": 83,
+        "height": 172,
+        "url": "https://example.org/iiif/image/full/83,172/0/default.jpg"
+      }
+    ],
+    "service": {
+      "url": "https://example.org/iiif/image"
+    }
+  }
+}
+```
+
+- Pick the smallest entry in `sizes` that is at least your target width. These are
+  sizes the server lists or its tiles precompute, so they are served fastest. Do not
+  rely on the array’s order.
+- Use `service` only for deep zoom or region crops.
+- `url` is the image as the manifest paints it, at full size.
+- A static image, one without an image service, has only `url`, `width` and
+  `height`: no `sizes` and no `service`, because it is the only version there is
+  and cannot be resized.
+- Without `representativeImage`, use `associatedMedia[].thumbnailUrl`, with no
+  dimensions. That is the case for a work with no manifest, no image in its manifest
+  with an image service or a stated size, or a fetch that has not succeeded yet.
+
+## Behaviour
+
+- **Selection:** the first painted image in the manifest that has an image service
+  or whose width and height the manifest states, found by
+  [@lde/iiif-image](https://ldelements.org/reference/iiif-image). A static image’s
+  size comes from the manifest; an image service’s from its `info.json`. Where that
+  `info.json` is gone, the image counts as static, if the manifest states its size.
+  An image whose `id` is not an absolute `http(s)` URL is passed over.
+- **Freshness:** manifest facts are refetched after 30 days, because which image
+  represents a work can change. `info.json` facts are refetched after 180 days: an
+  image’s dimensions do not change, but its server’s size URLs can.
+- **Safety:** fetches go through
+  [@lde/public-fetch](https://ldelements.org/reference/public-fetch), which refuses a
+  URL, or a redirect target, that is not `http(s)` or names a private address or
+  cluster-internal host, and caps a body at 20 MiB. A refused URL or a larger body is
+  reported and counts as having no such document. It looks at URLs only, so it does not catch DNS
+  pointing inwards. Run the indexer under an egress policy as well.
+- **Failures:** a failed fetch is reported and retried on a later run, and the work
+  is indexed without an image. A 401, 403, 404 or 410 counts as having no such
+  document and is rechecked after a week, so a brief 401 or 403 can replace a stored
+  fact for that long. So does a collection, which has no image of its own, and a
+  manifest too broken to read. A 200 that is no IIIF document at all, such as an error
+  page served as JSON, counts as a failure, so it is retried every run and five in a
+  row stop that dataset’s manifests for the run.
+- **Budget:** `fetchesPerRun` covers all datasets together. What it defers is not
+  reported, and those works are indexed without an image until a later run.
+- **Later runs:** retries, deferred works and refreshes all need the dataset to be
+  reprocessed. With `PROVENANCE_FILE`, an unchanged dataset waits until it changes
+  or `PIPELINE_VERSION` is bumped, so set `fetchesPerRun` high enough to cover it in
+  one run.
+- **Limits:** manifest requests are grouped per dataset, because manifest URLs often
+  sit on a redirector such as `n2t.net`, and `info.json` requests per host. Datasets
+  on one server are limited separately, with only the overall limit across them.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { iiifImages, type IiifImages, type IiifImagesContext, type IiifImagesOptions, type IiifImagesTransform, } from './lib/iiif-images.js';
+//# 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,OAAO,EACL,UAAU,EACV,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,GACzB,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export { iiifImages, } from './lib/iiif-images.js';

package/dist/lib/iiif-images.d.ts

@@ -0,0 +1,52 @@
+import { type ResolutionFailure } from '@lde/resolver';
+import type { RootType, SearchSchema } from '@lde/search';
+import type { Quad } from '@rdfjs/types';
+export interface IiifImagesOptions {
+    /**
+     * The SQLite file resolved facts live in between runs. It has to survive the
+     * run: the search index is rebuilt from it, and nothing else holds these facts.
+     */
+    readonly storePath: string;
+    /**
+     * Manifests, and separately `info.json` documents, this object may fetch across
+     * all datasets, so construct one per run. Defaults to the resolver’s 500.
+     *
+     * What the budget defers is not reported, and those works are indexed without an
+     * image. A cold store then warms only as datasets are reprocessed, so where
+     * unchanged datasets are skipped, set this high enough to cover them in one run.
+     */
+    readonly fetchesPerRun?: number;
+    /** Told about each reference that failed. Defaults to a console warning. */
+    readonly report?: (failure: ResolutionFailure) => void;
+}
+/** What the transform reads from the reader it is attached to. */
+export interface IiifImagesContext {
+    readonly dataset: {
+        readonly iri: URL;
+    };
+}
+/** A transform attachable to a reader as an `@lde/pipeline` `QuadTransform`. */
+export type IiifImagesTransform = (quads: AsyncIterable<Quad>, context: IiifImagesContext) => AsyncIterable<Quad>;
+export interface IiifImages {
+    /**
+     * The transform to attach to a root type’s reader, after any transform that
+     * repairs IRIs, or `undefined` where that type does not declare
+     * `representativeImage` and `associatedMedia` – so a deployment on an older
+     * schema loses the enrichment rather than the run.
+     */
+    transformFor(rootType: RootType): IiifImagesTransform | undefined;
+    /** Throws when the store cannot persist, to fail a run before it starts. */
+    check(): Promise<void>;
+}
+/**
+ * Enrich works with the image that represents them: its URL and dimensions, and
+ * for an image with an image service, a ladder of precomputed sizes, resolved
+ * from the work’s IIIF Presentation manifest and the selected image’s
+ * `info.json`. A static image is read from the manifest alone.
+ *
+ * A work with no manifest, or whose resolution has not succeeded, gets no
+ * `representativeImage`; consumers then fall back to the `thumbnailUrl` already
+ * in `associatedMedia`, and a failed resolution is retried on a later run.
+ */
+export declare function iiifImages(schema: SearchSchema, options: IiifImagesOptions): IiifImages;
+//# sourceMappingURL=iiif-images.d.ts.map

package/dist/lib/iiif-images.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iiif-images.d.ts","sourceRoot":"","sources":["../../src/lib/iiif-images.ts"],"names":[],"mappings":"AAWA,OAAO,EAKL,KAAK,iBAAiB,EAEvB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EACV,QAAQ,EAER,YAAY,EAEb,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,IAAI,EAA6B,MAAM,cAAc,CAAC;AASpE,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI,CAAC;CACxD;AAED,kEAAkE;AAClE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;KAAE,CAAC;CACzC;AAED,gFAAgF;AAChF,MAAM,MAAM,mBAAmB,GAAG,CAChC,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,EAC1B,OAAO,EAAE,iBAAiB,KACvB,aAAa,CAAC,IAAI,CAAC,CAAC;AAEzB,MAAM,WAAW,UAAU;IACzB;;;;;OAKG;IACH,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,mBAAmB,GAAG,SAAS,CAAC;IAClE,4EAA4E;IAC5E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,iBAAiB,GACzB,UAAU,CAoHZ"}

package/dist/lib/iiif-images.js

@@ -0,0 +1,337 @@
+import { images, readImageService, } from '@lde/iiif-image';
+import { fetchPublic, RefusedUrlError, ResponseTooLargeError, } from '@lde/public-fetch';
+import { createResolver, sqliteFactStore, urlHost, } from '@lde/resolver';
+import { fieldNamed, irAlias, referenceTypeNamed } from '@lde/search/adapter';
+import { DataFactory } from 'rdf-data-factory';
+import { iiifImage, iiifImageService, iiifImageSize, representativeImageField, } from '../schema.js';
+/**
+ * Enrich works with the image that represents them: its URL and dimensions, and
+ * for an image with an image service, a ladder of precomputed sizes, resolved
+ * from the work’s IIIF Presentation manifest and the selected image’s
+ * `info.json`. A static image is read from the manifest alone.
+ *
+ * A work with no manifest, or whose resolution has not succeeded, gets no
+ * `representativeImage`; consumers then fall back to the `thumbnailUrl` already
+ * in `associatedMedia`, and a failed resolution is retried on a later run.
+ */
+export function iiifImages(schema, options) {
+    const limits = options.fetchesPerRun === undefined
+        ? {}
+        : { fetchesPerResolver: options.fetchesPerRun };
+    const report = options.report ??
+        ((failure) => console.warn(`${failure.key}: ${failure.reason}`));
+    const manifests = createResolver({
+        key: (reference) => reference.url,
+        // Not the manifest’s own host: many are on n2t.net, which only redirects, so
+        // its limits and failure cut-off would land on the wrong server and lump
+        // publishers together. A dataset is the closest known stand-in for the server
+        // at the end of those redirects.
+        host: (reference) => reference.dataset,
+        fetch: (references, { signal }) => fetchFacts(references.map(({ url }) => url), (url) => url, (document) => {
+            try {
+                return firstUsable(images(document));
+            }
+            catch (error) {
+                // A document that says it is a collection, or a manifest too broken
+                // to read, has no image to offer: a fact about that document. Anything
+                // else – an error page served as JSON – is a server misbehaving, so
+                // no absence may overwrite the stored fact.
+                if (error instanceof TypeError && declaresIiifType(document)) {
+                    return undefined;
+                }
+                throw error;
+            }
+        }, signal, report),
+        store: sqliteFactStore({
+            path: options.storePath,
+            table: 'manifests',
+        }),
+        // 2: the selected image rather than its service’s URL, and static images too.
+        version: '2',
+        limits: { ...limits, ttlMs: MANIFEST_TTL_MS },
+        report,
+    });
+    const services = createResolver({
+        key: (service) => service,
+        host: urlHost,
+        fetch: (services, { signal }) => fetchFacts(services, (service) => `${service}/info.json`, (info, service) => {
+            // Same reasoning, with more at stake: these facts are otherwise permanent.
+            const fact = readImageService(service, info);
+            if (fact === undefined) {
+                throw new Error(`${service}/info.json states no dimensions`);
+            }
+            return fact;
+        }, signal, report),
+        store: sqliteFactStore({
+            path: options.storePath,
+            table: 'images',
+        }),
+        limits: { ...limits, ttlMs: IMAGE_TTL_MS },
+        report,
+    });
+    return {
+        transformFor(rootType) {
+            const aliases = aliasesOf(rootType, schema);
+            return aliases === undefined
+                ? undefined
+                : async function* enrich(quads, context) {
+                    // A batch of roots is the unit of work and what bounds the memory: a
+                    // work’s manifest entry is only known once the batch is, and resolving
+                    // per batch is what lets the resolver share one store read.
+                    const batch = [];
+                    for await (const quad of quads) {
+                        batch.push(quad);
+                        yield quad;
+                    }
+                    const manifestOfWork = manifestsIn(batch, aliases);
+                    const dataset = context.dataset.iri.toString();
+                    const selected = await manifests.resolveAll([...manifestOfWork.values()].map((url) => ({ url, dataset })));
+                    const imageOfWork = new Map();
+                    for (const [work, manifest] of manifestOfWork) {
+                        const resolution = selected.get(manifest);
+                        if (resolution?.outcome === 'resolved') {
+                            imageOfWork.set(work, resolution.fact);
+                        }
+                    }
+                    const resolved = await services.resolveAll([...imageOfWork.values()].flatMap(({ service }) => service === undefined ? [] : [service]));
+                    for (const [work, image] of imageOfWork) {
+                        const representative = representativeOf(image, resolved);
+                        if (representative !== undefined) {
+                            yield* mint(factory.namedNode(work), representative, aliases);
+                        }
+                    }
+                };
+        },
+        async check() {
+            await manifests.check();
+            await services.check();
+        },
+    };
+}
+const factory = new DataFactory();
+const INTEGER = factory.namedNode('http://www.w3.org/2001/XMLSchema#integer');
+/** What the profile’s `encodingFormat` for a manifest entry contains. */
+const IIIF_PRESENTATION_CONTEXT = 'iiif.io/api/presentation';
+/** A manifest’s selection can change, so it is reconsidered after 30 days. */
+const MANIFEST_TTL_MS = 30 * 24 * 3_600_000;
+/**
+ * An image’s dimensions do not change, but what its server offers does: an upgrade
+ * can change the size URLs stored with them. So these facts are reconsidered too,
+ * only rarely.
+ */
+const IMAGE_TTL_MS = 180 * 24 * 3_600_000;
+const IIIF_TYPES = new Set([
+    'Manifest',
+    'Collection',
+    'sc:Manifest',
+    'sc:Collection',
+]);
+/** Answers meaning this document is not ours to have, now or on a retry. */
+const ABSENT_STATUSES = new Set([401, 403, 404, 410]);
+/**
+ * The first image that can represent the work: one with an image service, whose
+ * `info.json` states its dimensions, or a static image whose manifest states
+ * them. Without a size to state, a static image adds nothing to the
+ * `thumbnailUrl` consumers already have. Its URL is minted as an IRI, so an image
+ * whose `id` is not an absolute web address is passed over.
+ */
+function firstUsable(painted) {
+    for (const image of painted) {
+        const url = webAddress(image.url);
+        if (url !== undefined &&
+            (image.service !== undefined || staticOf(image) !== undefined)) {
+            return { ...image, url };
+        }
+    }
+    return undefined;
+}
+/**
+ * The image to mint, or `undefined` while its image service is not resolved.
+ * An image service found to be gone leaves the size the manifest states, if any.
+ */
+function representativeOf(image, resolved) {
+    const resolution = image.service === undefined ? undefined : resolved.get(image.service);
+    if (resolution?.outcome === 'resolved') {
+        return { ...resolution.fact, url: image.url, service: resolution.fact.url };
+    }
+    return image.service === undefined || resolution?.outcome === 'absent'
+        ? staticOf(image)
+        : undefined;
+}
+/** The image as the manifest states it, without sizes or a service. */
+function staticOf(image) {
+    return image.width === undefined || image.height === undefined
+        ? undefined
+        : { url: image.url, width: image.width, height: image.height, sizes: [] };
+}
+/** The URL, normalised, if it is an absolute `http(s)` one. */
+function webAddress(url) {
+    if (!URL.canParse(url)) {
+        return undefined;
+    }
+    const { protocol, href } = new URL(url);
+    return protocol === 'http:' || protocol === 'https:' ? href : undefined;
+}
+function aliasesOf(rootType, schema) {
+    const media = fieldNamed(rootType, 'associatedMedia');
+    const image = fieldNamed(rootType, representativeImageField.name);
+    const mediaType = referencedType(schema, media);
+    const encodingFormat = mediaType === undefined ? undefined : aliasOf(mediaType, 'encodingFormat');
+    const imageType = referencedType(schema, image);
+    const sizeType = imageType && referencedType(schema, fieldNamed(imageType, 'sizes'));
+    const serviceType = imageType && referencedType(schema, fieldNamed(imageType, 'service'));
+    if (media === undefined ||
+        image === undefined ||
+        encodingFormat === undefined ||
+        imageType === undefined ||
+        sizeType === undefined ||
+        serviceType === undefined) {
+        return undefined;
+    }
+    const imageAliases = fieldAliases(imageType, iiifImage);
+    const sizeAliases = fieldAliases(sizeType, iiifImageSize);
+    const serviceAliases = fieldAliases(serviceType, iiifImageService);
+    return imageAliases === undefined ||
+        sizeAliases === undefined ||
+        serviceAliases === undefined
+        ? undefined
+        : {
+            associatedMedia: irAlias(rootType, media),
+            encodingFormat,
+            representativeImage: irAlias(rootType, image),
+            image: imageAliases,
+            size: sizeAliases,
+            service: serviceAliases,
+        };
+}
+/**
+ * The type a reference field nests. Read from the declaration rather than through
+ * `nestedReferenceType`, which answers only for surfaced fields: a schema may read
+ * `associatedMedia` without surfacing it, and should still be enriched.
+ */
+function referencedType(schema, field) {
+    return field?.kind === 'reference' && field.ref?.strategy === 'inline'
+        ? referenceTypeNamed(schema, field.ref.typeName)
+        : undefined;
+}
+/** Every field `declaration` names, as the schema’s own `searchType` aliases it,
+ *  or `undefined` where that type lacks one. */
+function fieldAliases(searchType, declaration) {
+    const entries = declaration.fields.map(({ name }) => [name, aliasOf(searchType, name)]);
+    return entries.every(([, alias]) => alias !== undefined)
+        ? Object.fromEntries(entries)
+        : undefined;
+}
+function aliasOf(searchType, name) {
+    const field = fieldNamed(searchType, name);
+    return field === undefined ? undefined : irAlias(searchType, field);
+}
+/**
+ * Each work’s manifest: its `associatedMedia` entry that is a named node and names
+ * the IIIF Presentation context in its `encodingFormat`. The profile allows one;
+ * where a publisher states more, the first by IRI, because quad order can change
+ * between runs and the representative image should not change with it. Only works
+ * named by an IRI, because the image is minted onto the work by its name.
+ */
+function manifestsIn(batch, aliases) {
+    const manifestEntries = new Set(batch
+        .filter((quad) => quad.predicate.value === aliases.encodingFormat &&
+        quad.subject.termType === 'NamedNode' &&
+        quad.object.value.includes(IIIF_PRESENTATION_CONTEXT))
+        .map((quad) => quad.subject.value));
+    const manifestOfWork = new Map();
+    for (const quad of batch) {
+        if (quad.predicate.value !== aliases.associatedMedia ||
+            quad.subject.termType !== 'NamedNode' ||
+            !manifestEntries.has(quad.object.value)) {
+            continue;
+        }
+        const current = manifestOfWork.get(quad.subject.value);
+        if (current === undefined || quad.object.value < current) {
+            manifestOfWork.set(quad.subject.value, quad.object.value);
+        }
+    }
+    return manifestOfWork;
+}
+/**
+ * Fetch each key’s JSON document and derive its fact. An {@link ABSENT_STATUSES}
+ * answer, or a document `derive` finds no fact in, is an absence and left out;
+ * anything else throws, so the resolver retries it and a stored fact survives a
+ * passing outage. Restricted images are absences so that they cannot write off a
+ * host whose public images are fine. So, reported, is a URL that is not a public
+ * web address – publisher data decides these URLs, and this runs inside the
+ * cluster – and a document too large to read, which a retry would not shrink.
+ */
+async function fetchFacts(keys, urlOf, derive, signal, report) {
+    const facts = [];
+    for (const key of keys) {
+        let document;
+        try {
+            document = await fetchDocument(urlOf(key), signal);
+        }
+        catch (error) {
+            if (!(error instanceof RefusedUrlError) &&
+                !(error instanceof ResponseTooLargeError)) {
+                throw error;
+            }
+            report({ key, reason: error.message, degradedToStore: false });
+            continue;
+        }
+        const fact = document === undefined ? undefined : derive(document, key);
+        if (fact !== undefined) {
+            facts.push([key, fact]);
+        }
+    }
+    return facts;
+}
+/** The JSON document at `url`, or `undefined` for an {@link ABSENT_STATUSES} answer. */
+async function fetchDocument(url, signal) {
+    // Only `*/*`: LDmaX answers 404 to any JSON media type in `Accept`, IIIF’s own
+    // included, even with `*/*` as a fallback beside it.
+    const response = await fetchPublic(url, {
+        signal,
+        headers: { Accept: '*/*' },
+    });
+    if (!response.ok) {
+        // An unread body keeps its connection until garbage collection.
+        await response.body?.cancel();
+        if (ABSENT_STATUSES.has(response.status)) {
+            return undefined;
+        }
+        throw new Error(`${url} answered ${response.status}`);
+    }
+    return response.json();
+}
+/** Whether a document says it is a IIIF manifest or collection, in Presentation 3 or 2. */
+function declaresIiifType(document) {
+    if (typeof document !== 'object' || document === null) {
+        return false;
+    }
+    const { type, '@type': legacyType } = document;
+    return IIIF_TYPES.has(String(type ?? legacyType));
+}
+function* mint(work, fact, aliases) {
+    const image = factory.blankNode();
+    yield triple(work, aliases.representativeImage, image);
+    yield triple(image, aliases.image.url, factory.namedNode(fact.url));
+    yield triple(image, aliases.image.width, integer(fact.width));
+    yield triple(image, aliases.image.height, integer(fact.height));
+    for (const size of fact.sizes) {
+        const node = factory.blankNode();
+        yield triple(image, aliases.image.sizes, node);
+        yield triple(node, aliases.size.width, integer(size.width));
+        yield triple(node, aliases.size.height, integer(size.height));
+        yield triple(node, aliases.size.url, factory.namedNode(size.url));
+    }
+    if (fact.service !== undefined) {
+        const service = factory.blankNode();
+        yield triple(image, aliases.image.service, service);
+        yield triple(service, aliases.service.url, factory.namedNode(fact.service));
+    }
+}
+function triple(subject, predicate, object) {
+    return factory.quad(subject, factory.namedNode(predicate), object);
+}
+function integer(value) {
+    return factory.literal(String(value), INTEGER);
+}

package/dist/schema.d.ts

@@ -0,0 +1,169 @@
+/** One precomputed rendition of the image, with the URL to request it at. */
+export declare const iiifImageSize: {
+    readonly name: "IiifImageSize";
+    readonly fields: readonly [{
+        readonly name: "width";
+        readonly kind: "integer";
+        readonly output: true;
+        readonly path: "<https://schema.org/width>";
+    }, {
+        readonly name: "height";
+        readonly kind: "integer";
+        readonly output: true;
+        readonly path: "<https://schema.org/height>";
+    }, {
+        readonly name: "url";
+        readonly kind: "reference";
+        readonly output: true;
+        readonly path: "<https://schema.org/contentUrl>";
+        readonly ref: {
+            readonly strategy: "idOnly";
+        };
+    }];
+};
+/** The IIIF image service itself, for consumers doing deep zoom or region crops. */
+export declare const iiifImageService: {
+    readonly name: "IiifImageService";
+    readonly fields: readonly [{
+        readonly name: "url";
+        readonly kind: "reference";
+        readonly output: true;
+        readonly path: "<https://schema.org/url>";
+        readonly ref: {
+            readonly strategy: "idOnly";
+        };
+    }];
+};
+/**
+ * The image that represents a work: the image the manifest paints, its full
+ * dimensions, and the renditions a consumer can pick from without knowing Image
+ * API compliance levels.
+ */
+export declare const iiifImage: {
+    readonly name: "IiifImage";
+    readonly fields: readonly [{
+        readonly name: "url";
+        readonly kind: "reference";
+        readonly output: true;
+        readonly path: "<https://schema.org/contentUrl>";
+        readonly ref: {
+            readonly strategy: "idOnly";
+        };
+    }, {
+        readonly name: "width";
+        readonly kind: "integer";
+        readonly output: true;
+        readonly path: "<https://schema.org/width>";
+    }, {
+        readonly name: "height";
+        readonly kind: "integer";
+        readonly output: true;
+        readonly path: "<https://schema.org/height>";
+    }, {
+        readonly name: "sizes";
+        readonly kind: "reference";
+        readonly array: true;
+        readonly output: true;
+        readonly path: "<https://def.nde.nl/iiif#size>";
+        readonly ref: {
+            readonly typeName: "IiifImageSize";
+            readonly strategy: "inline";
+        };
+    }, {
+        readonly name: "service";
+        readonly kind: "reference";
+        readonly output: true;
+        readonly path: "<https://def.nde.nl/iiif#service>";
+        readonly ref: {
+            readonly typeName: "IiifImageService";
+            readonly strategy: "inline";
+        };
+    }];
+};
+/** The types {@link representativeImageField} nests, to add to the schema. */
+export declare const iiifImageTypes: ({
+    readonly name: "IiifImageSize";
+    readonly fields: readonly [{
+        readonly name: "width";
+        readonly kind: "integer";
+        readonly output: true;
+        readonly path: "<https://schema.org/width>";
+    }, {
+        readonly name: "height";
+        readonly kind: "integer";
+        readonly output: true;
+        readonly path: "<https://schema.org/height>";
+    }, {
+        readonly name: "url";
+        readonly kind: "reference";
+        readonly output: true;
+        readonly path: "<https://schema.org/contentUrl>";
+        readonly ref: {
+            readonly strategy: "idOnly";
+        };
+    }];
+} | {
+    readonly name: "IiifImageService";
+    readonly fields: readonly [{
+        readonly name: "url";
+        readonly kind: "reference";
+        readonly output: true;
+        readonly path: "<https://schema.org/url>";
+        readonly ref: {
+            readonly strategy: "idOnly";
+        };
+    }];
+} | {
+    readonly name: "IiifImage";
+    readonly fields: readonly [{
+        readonly name: "url";
+        readonly kind: "reference";
+        readonly output: true;
+        readonly path: "<https://schema.org/contentUrl>";
+        readonly ref: {
+            readonly strategy: "idOnly";
+        };
+    }, {
+        readonly name: "width";
+        readonly kind: "integer";
+        readonly output: true;
+        readonly path: "<https://schema.org/width>";
+    }, {
+        readonly name: "height";
+        readonly kind: "integer";
+        readonly output: true;
+        readonly path: "<https://schema.org/height>";
+    }, {
+        readonly name: "sizes";
+        readonly kind: "reference";
+        readonly array: true;
+        readonly output: true;
+        readonly path: "<https://def.nde.nl/iiif#size>";
+        readonly ref: {
+            readonly typeName: "IiifImageSize";
+            readonly strategy: "inline";
+        };
+    }, {
+        readonly name: "service";
+        readonly kind: "reference";
+        readonly output: true;
+        readonly path: "<https://def.nde.nl/iiif#service>";
+        readonly ref: {
+            readonly typeName: "IiifImageService";
+            readonly strategy: "inline";
+        };
+    }];
+})[];
+/** Add to a root type’s fields, and {@link iiifImageTypes} to the schema, to opt
+ *  that type in to enrichment. */
+export declare const representativeImageField: {
+    readonly name: "representativeImage";
+    readonly kind: "reference";
+    readonly output: true;
+    readonly path: "<https://def.nde.nl/iiif#representativeImage>";
+    readonly ref: {
+        readonly typeName: "IiifImage";
+        readonly strategy: "inline";
+    };
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAKA,6EAA6E;AAC7E,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;CAkBK,CAAC;AAEhC,oFAAoF;AACpF,eAAO,MAAM,gBAAgB;;;;;;;;;;;CAWE,CAAC;AAEhC;;;;GAIG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCS,CAAC;AAEhC,8EAA8E;AAC9E,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAA+C,CAAC;AAE3E;kCACkC;AAClC,eAAO,MAAM,wBAAwB;;;;;;;;;CAML,CAAC"}

package/dist/schema.js

@@ -0,0 +1,85 @@
+const SCHEMA = 'https://schema.org/';
+const IIIF = 'https://def.nde.nl/iiif#';
+/** One precomputed rendition of the image, with the URL to request it at. */
+export const iiifImageSize = {
+    name: 'IiifImageSize',
+    fields: [
+        { name: 'width', kind: 'integer', output: true, path: `<${SCHEMA}width>` },
+        {
+            name: 'height',
+            kind: 'integer',
+            output: true,
+            path: `<${SCHEMA}height>`,
+        },
+        {
+            name: 'url',
+            kind: 'reference',
+            output: true,
+            path: `<${SCHEMA}contentUrl>`,
+            ref: { strategy: 'idOnly' },
+        },
+    ],
+};
+/** The IIIF image service itself, for consumers doing deep zoom or region crops. */
+export const iiifImageService = {
+    name: 'IiifImageService',
+    fields: [
+        {
+            name: 'url',
+            kind: 'reference',
+            output: true,
+            path: `<${SCHEMA}url>`,
+            ref: { strategy: 'idOnly' },
+        },
+    ],
+};
+/**
+ * The image that represents a work: the image the manifest paints, its full
+ * dimensions, and the renditions a consumer can pick from without knowing Image
+ * API compliance levels.
+ */
+export const iiifImage = {
+    name: 'IiifImage',
+    fields: [
+        {
+            name: 'url',
+            kind: 'reference',
+            output: true,
+            path: `<${SCHEMA}contentUrl>`,
+            ref: { strategy: 'idOnly' },
+        },
+        { name: 'width', kind: 'integer', output: true, path: `<${SCHEMA}width>` },
+        {
+            name: 'height',
+            kind: 'integer',
+            output: true,
+            path: `<${SCHEMA}height>`,
+        },
+        {
+            name: 'sizes',
+            kind: 'reference',
+            array: true,
+            output: true,
+            path: `<${IIIF}size>`,
+            ref: { typeName: iiifImageSize.name, strategy: 'inline' },
+        },
+        {
+            name: 'service',
+            kind: 'reference',
+            output: true,
+            path: `<${IIIF}service>`,
+            ref: { typeName: iiifImageService.name, strategy: 'inline' },
+        },
+    ],
+};
+/** The types {@link representativeImageField} nests, to add to the schema. */
+export const iiifImageTypes = [iiifImage, iiifImageSize, iiifImageService];
+/** Add to a root type’s fields, and {@link iiifImageTypes} to the schema, to opt
+ *  that type in to enrichment. */
+export const representativeImageField = {
+    name: 'representativeImage',
+    kind: 'reference',
+    output: true,
+    path: `<${IIIF}representativeImage>`,
+    ref: { typeName: iiifImage.name, strategy: 'inline' },
+};

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@ndes/iiif-images",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Enriches SCHEMA-AP-NDE works with the dimensions and sizes of their representative IIIF image, as a quad transform for the search indexer.",
+  "repository": {
+    "url": "git+https://github.com/netwerk-digitaal-erfgoed/stack.git",
+    "directory": "packages/iiif-images"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@ndes/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./schema": {
+      "@ndes/source": "./src/schema.ts",
+      "types": "./dist/schema.d.ts",
+      "import": "./dist/schema.js",
+      "default": "./dist/schema.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "@lde/iiif-image": "^0.2.0",
+    "@lde/public-fetch": "^0.1.0",
+    "@lde/resolver": "^0.2.1",
+    "@rdfjs/types": "^2.0.1",
+    "rdf-data-factory": "^2.1.0",
+    "tslib": "^2.3.0"
+  },
+  "devDependencies": {
+    "@lde/pipeline": "^0.36.7",
+    "@lde/search": "^0.34.0"
+  },
+  "peerDependencies": {
+    "@lde/search": "^0.34.0"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "nx": {
+    "name": "iiif-images"
+  }
 }