linked-rolls 0.62.0 → 0.64.0

package/lib/io/importJsonLd.js

@@ -1,6 +1,7 @@
 import { derivedKeys } from "./asJsonLd.js";
 import { migrate, plainCopyId } from "./migrate.js";
 import { isDateString } from "../shared/utils.js";
+import { putOnAxis } from "../collation/alignment.js";
 import schema from "../schema.json" with { type: 'json' };
 export const importDate = (str) => {
     const [y, m, d] = str.split('-').map(s => parseInt(s, 10));
@@ -70,6 +71,16 @@ const withPlainCopyIds = (json) => ({
         '@id': typeof copy['@id'] === 'string' ? plainCopyId(copy['@id']) : copy['@id']
     }))
 });
+/** The document without the creations an export gave versions that state none. */
+const withoutEmptyCreations = (json) => Array.isArray(json.versions)
+    ? {
+        ...json,
+        versions: json.versions.map((version) => {
+            const { creation, ...rest } = version;
+            return creation !== null && typeof creation === 'object' && Object.keys(creation).length === 0 ? rest : version;
+        })
+    }
+    : json;
 /** A statement an export quoted rather than stated: an included node whose id is a triple. */
 const isQuotedStatement = (node) => node !== null && typeof node === 'object' && node['@id'] !== null && typeof node['@id'] === 'object';
 /** The reference a quoted statement made, annotated again with the belief the export set beside it. */
@@ -118,11 +129,17 @@ const withQuotedStatementsInPlace = (edition) => {
     const bySubject = Map.groupBy(statements.map(referenceOf), ({ subject }) => subject);
     return withReferencesOn({ ...rest, ...(others.length > 0 && { '@included': others }) }, bySubject);
 };
+/**
+ * Reads an edition. A document holds each copy's features and tears at
+ * the copy's own places, as they were read; the edition holds them on
+ * its axis, which is where the copy's alignment carries them.
+ */
 export const importJsonLd = (json) => {
-    const { '@context': context, ...document } = withPlainCopyIds(migrate(withQuotedStatementsInPlace(json)));
+    const { '@context': context, ...document } = withoutEmptyCreations(withPlainCopyIds(migrate(withQuotedStatementsInPlace(json))));
     const edition = fromJsonLdEntity(document);
     edition.base = Array.isArray(context)
         ? context.find((c) => c['@base'])?.['@base'] || ''
         : '';
+    (edition.copies ?? []).forEach(putOnAxis);
     return edition;
 };

package/lib/io/migrate.js

@@ -360,6 +360,78 @@ const withFeaturesInActs = (node) => {
         modifications: [...acts, ...(loose.length > 0 ? [{ '@type': 'Attachment', added: loose }] : [])]
     };
 };
+/** A place written to the nanometre, as the export writes places it has carried off the axis. */
+const writtenPlace = (place) => Math.round(place * 1e6) / 1e6;
+/** The span with both ends taken through the mapping, the far end only where it has one. */
+const spanThrough = (span, through) => span && typeof span.from === 'number'
+    ? { ...span, from: through(span.from), ...(typeof span.to === 'number' && { to: through(span.to) }) }
+    : span;
+const isLegacyAligned = (copy) => copy?.measurements?.shift !== undefined || copy?.measurements?.scale !== undefined;
+const isLegacyPaperStretch = (condition) => isPaperStretch(condition) && Object.hasOwn(condition, 'factor');
+const conditionTypeOf = (condition) => condition?.conditionType ?? condition?.['@type'];
+/**
+ * A copy's features once stood where its alignment had put them, on the
+ * edition's axis, with the shift and the scale that had done it recorded
+ * beside them. They stand at the copy's own places now, as they were
+ * read, and the alignment says how they go onto the axis; so they are
+ * taken back by it, and so are the tears, which were measured as the
+ * features are. The features are in their acts here, `withFeaturesInActs`
+ * having run.
+ *
+ * The factor of a paper-stretch condition was the alignment's scale
+ * stated again, which is how every such condition came about. It is
+ * dropped: the scale stays with the alignment, and what it says about the
+ * paper is worked out from all the alignments together.
+ */
+const withOwnPlaces = (node) => {
+    if (node['@type'] !== 'RollCopy' || !isLegacyAligned(node))
+        return node;
+    const { shift: legacyShift, scale: legacyScale, ...measurements } = node.measurements;
+    const shift = {
+        horizontal: legacyShift?.horizontal ?? 0,
+        vertical: legacyShift?.vertical ?? 0
+    };
+    const scale = legacyScale ?? 1;
+    const along = (place) => writtenPlace(place / scale - shift.horizontal);
+    const across = (position) => position - shift.vertical;
+    const ownFeature = (feature) => {
+        if (!feature || typeof feature !== 'object' || !feature.horizontal)
+            return feature;
+        return {
+            ...feature,
+            horizontal: spanThrough(feature.horizontal, along),
+            ...(feature.vertical?.unit === 'track' && shift.vertical !== 0 && { vertical: spanThrough(feature.vertical, across) })
+        };
+    };
+    const ownFeatures = (features) => Array.isArray(features) ? features.map(ownFeature) : features;
+    const production = node.production && {
+        ...node.production,
+        ...(Array.isArray(node.production.produced) && { produced: ownFeatures(node.production.produced) })
+    };
+    const modifications = Array.isArray(node.modifications)
+        ? node.modifications.map((act) => act && typeof act === 'object'
+            ? {
+                ...act,
+                ...(Array.isArray(act.produced) && { produced: ownFeatures(act.produced) }),
+                ...(Array.isArray(act.added) && { added: ownFeatures(act.added) })
+            }
+            : act)
+        : node.modifications;
+    const conditions = Array.isArray(node.conditions)
+        ? node.conditions
+            .filter((condition) => !isLegacyPaperStretch(condition))
+            .map((condition) => conditionTypeOf(condition) === 'torn' && condition.horizontal
+            ? { ...condition, horizontal: spanThrough(condition.horizontal, along) }
+            : condition)
+        : node.conditions;
+    return {
+        ...node,
+        measurements: { ...measurements, alignment: { shift, scale } },
+        ...(production && { production }),
+        ...(modifications && { modifications }),
+        ...(conditions && { conditions })
+    };
+};
 /** A keeper nobody could name was written as an empty one before a copy could leave it out. */
 const withoutEmptyKeeper = (node) => {
     if (node.keeper?.name !== '' || node.keeper.sameAs?.length)
@@ -380,7 +452,7 @@ const withTimeSpanDates = (node) => {
 };
 const migrateNode = (node) => [withRenamedKeys, withRenamedEditType, withTypology, withRenamedType, withoutVersionType, withoutVersionSiglum, withLowerCaseTerms, withSplitMethod, withReferences, withKeeper, withoutEmptyKeeper,
     withPerforator, withProductionNodes, withTypedPerforator, withScale, withoutOps, withDerivationList, withReadingKind, withTimeSpanDates,
-    withoutFeatureKind, withBorneFeaturesNamed, withFeaturesInActs, withDriveOfStaggering, withoutPattern, withoutBearings, withoutEntailedType]
+    withoutFeatureKind, withBorneFeaturesNamed, withFeaturesInActs, withOwnPlaces, withDriveOfStaggering, withoutPattern, withoutBearings, withoutEntailedType]
     .reduce((result, step) => step(result), node);
 /** The items each walked, or the very same list where the walk changed none. */
 const walked = (items) => {
@@ -525,5 +597,25 @@ const withoutFormatVersion = (edition) => {
     const { formatVersion: _stated, ...rest } = edition;
     return rest;
 };
-const editionSteps = [withoutFormatVersion, withoutEditionType, withSystems, withEditors, withDerivationTolerance];
+/** Whether the copy states features, in either shape. */
+const hasFeatures = (copy) => [copy?.features, copy?.production?.produced, copy?.productionEvent?.produced]
+    .some(features => Array.isArray(features) && features.length > 0);
+const statesLegacyAlignment = (copy) => isLegacyAligned(copy)
+    || (Array.isArray(copy?.ops) && (copy.ops.includes('shifted') || copy.ops.includes('stretched')));
+/**
+ * The copy whose millimetres were the edition's axis went unnamed while
+ * the copies aligned onto it recorded only what had been done to them.
+ * It was the copy nothing had been done to, and of those the first with
+ * features, so that is the one named.
+ */
+const withReferenceCopy = (edition) => {
+    const copies = listAt(edition, 'copies');
+    if (edition.referenceCopy !== undefined || !copies?.some(statesLegacyAlignment))
+        return edition;
+    const reference = copies.find(copy => !statesLegacyAlignment(copy) && hasFeatures(copy));
+    return typeof reference?.['@id'] === 'string'
+        ? { ...edition, referenceCopy: plainCopyId(reference['@id']) }
+        : edition;
+};
+const editionSteps = [withoutFormatVersion, withoutEditionType, withSystems, withEditors, withDerivationTolerance, withReferenceCopy];
 export const migrate = (edition) => walk(editionSteps.reduce((result, step) => step(result), edition));

package/lib/lookup/lookup.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Finding what an edition holds by its id. Each kind of entity has an
+ * index of its own, built from where the edition holds it when first
+ * asked for and kept for as long as the state is (`perState`). The index
+ * an entity is found in says what it is, so a lookup needs neither a
+ * type discriminator nor a cast.
+ */
+import { Edition } from "../model/Edition.js";
+import { NestedFeature } from "../model/Feature.js";
+import { AnySymbol } from "../model/Symbol.js";
+import { Version } from "../model/Version.js";
+import { Modification, ProductionEvent, RollCopy } from "../model/RollCopy.js";
+export declare const versionIn: (edition: Pick<Edition, 'versions'>, id: string) => Readonly<Version> | undefined;
+export declare const copyIn: (edition: Pick<Edition, 'copies'>, id: string) => Readonly<RollCopy> | undefined;
+/** A symbol any version inserts. */
+export declare const symbolIn: (edition: Pick<Edition, 'versions'>, id: string) => Readonly<AnySymbol> | undefined;
+/** The symbols under the ids, leaving out an id that names none. */
+export declare const symbolsIn: (edition: Pick<Edition, 'versions'>, ids: readonly string[]) => Readonly<AnySymbol>[];
+/** A feature or a patch on any copy, one a patch bears included. */
+export declare const featureIn: (edition: Pick<Edition, 'copies'>, id: string) => Readonly<NestedFeature> | undefined;
+/** The features and patches under the ids, leaving out an id that names none. */
+export declare const featuresIn: (edition: Pick<Edition, 'copies'>, ids: readonly string[]) => Readonly<NestedFeature>[];
+/** The copy a feature sits on, a patch and everything it bears included. */
+export declare const copyOfFeature: (edition: Pick<Edition, 'copies'>, featureId: string) => Readonly<RollCopy> | undefined;
+/**
+ * The act a copy states a feature in: the production event that
+ * punched it, or the modification that brought it about. A feature
+ * a patch bears came onto the copy with the patch, so the act is
+ * the one that glued the patch on. Two features stand in one act
+ * where this returns the very same object.
+ */
+export declare const actOf: (edition: Pick<Edition, 'copies'>, featureId: string) => Readonly<ProductionEvent | Modification> | undefined;

package/lib/lookup/lookup.js

@@ -0,0 +1,40 @@
+import { withBorneFeatures } from "../model/Feature.js";
+import { insertedBy } from "../model/Version.js";
+import { featuresMadeBy, featuresOf } from "../model/RollCopy.js";
+import { perState } from "./perState.js";
+const byIdIn = (entities) => new Map(entities.map(entity => [entity.id, entity]));
+const versionsById = perState((edition) => byIdIn(edition.versions));
+const copiesById = perState((edition) => byIdIn(edition.copies));
+const symbolsById = perState((edition) => byIdIn(edition.versions.flatMap(insertedBy)));
+/** Every feature and patch on the copies, those a patch bears included. */
+const featuresOnCopies = (edition) => edition.copies.flatMap(copy => featuresOf(copy).flatMap(withBorneFeatures).map(feature => ({ feature, copy })));
+const featuresById = perState((edition) => new Map(featuresOnCopies(edition).map(({ feature }) => [feature.id, feature])));
+const copiesByFeature = perState((edition) => new Map(featuresOnCopies(edition).map(({ feature, copy }) => [feature.id, copy])));
+export const versionIn = (edition, id) => versionsById(edition).get(id);
+export const copyIn = (edition, id) => copiesById(edition).get(id);
+/** A symbol any version inserts. */
+export const symbolIn = (edition, id) => symbolsById(edition).get(id);
+/** The symbols under the ids, leaving out an id that names none. */
+export const symbolsIn = (edition, ids) => ids.flatMap(id => symbolIn(edition, id) ?? []);
+/** A feature or a patch on any copy, one a patch bears included. */
+export const featureIn = (edition, id) => featuresById(edition).get(id);
+/** The features and patches under the ids, leaving out an id that names none. */
+export const featuresIn = (edition, ids) => ids.flatMap(id => featureIn(edition, id) ?? []);
+/** The copy a feature sits on, a patch and everything it bears included. */
+export const copyOfFeature = (edition, featureId) => copiesByFeature(edition).get(featureId);
+/**
+ * The act a copy states a feature in: the production event that
+ * punched it, or the modification that brought it about. A feature
+ * a patch bears came onto the copy with the patch, so the act is
+ * the one that glued the patch on. Two features stand in one act
+ * where this returns the very same object.
+ */
+export const actOf = (edition, featureId) => {
+    const copy = copyOfFeature(edition, featureId);
+    if (!copy)
+        return undefined;
+    const states = (features) => features.flatMap(withBorneFeatures).some(feature => feature.id === featureId);
+    if (states(copy.production?.produced ?? []))
+        return copy.production;
+    return copy.modifications.find(act => states(featuresMadeBy(act)));
+};

package/lib/lookup/paths.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Where in an edition each id stands and where it is referenced, as
+ * paths an operation can follow into a draft of it.
+ */
+import { Edition } from "../model/Edition.js";
+export type Path = (string | number)[];
+export declare const getAt: <T>(path: Path, obj: unknown) => T | undefined;
+/** Where the entity with the id stands in the edition, or nothing where it holds none. */
+export declare const pathIn: (edition: Edition, id: string) => Path | undefined;
+/** Where the edition references the id. */
+export declare const linksTo: (edition: Edition, id: string) => Path[];

package/lib/lookup/paths.js

@@ -0,0 +1,78 @@
+import { perState } from "./perState.js";
+export const getAt = (path, obj) => {
+    let node = obj;
+    for (const key of path) {
+        if (node == null)
+            return undefined;
+        node = node[key];
+    }
+    return node;
+};
+/** Keys under which an object names others by id, singly or in a list. */
+const referenceKeys = ['delete', 'comprehends', 'motivation', 'premises', 'used'];
+const isObject = (v) => v !== null && typeof v === "object";
+/** What a reference may state besides the id: a belief about it, and the tolerance a derivation was collated at. */
+const referenceOwnKeys = new Set(['id', '@annotation', 'collationTolerance']);
+/** An object that names another by its id and says nothing of its own beyond that. */
+const isReferenceOnly = (keys) => keys.every(key => referenceOwnKeys.has(key));
+const laidOut = (trail) => {
+    const path = [];
+    for (let link = trail; link !== null; link = link.up)
+        path.push(link.key);
+    return path.reverse();
+};
+/** Walks the edition and records where each id stands and where it is referenced. */
+const placesIn = perState((edition) => {
+    const paths = new Map();
+    const links = new Map();
+    const visited = new WeakSet();
+    const link = (id, trail) => {
+        const trails = links.get(id);
+        if (trails)
+            trails.push(trail);
+        else
+            links.set(id, [trail]);
+    };
+    const index = (record, keys, trail) => {
+        if (typeof record.id !== "string")
+            return;
+        if (isReferenceOnly(keys))
+            link(record.id, { key: 'id', up: trail });
+        else if (!paths.has(record.id)) {
+            paths.set(record.id, trail);
+        }
+    };
+    const linkReferences = (record, trail) => referenceKeys.forEach(key => {
+        const ref = record[key];
+        if (typeof ref === "string")
+            link(ref, { key, up: trail });
+        else if (Array.isArray(ref))
+            ref.forEach((r, i) => {
+                if (typeof r === "string")
+                    link(r, { key: i, up: { key, up: trail } });
+            });
+    });
+    const traverse = (node, trail) => {
+        if (!isObject(node) || visited.has(node))
+            return;
+        visited.add(node);
+        if (Array.isArray(node)) {
+            node.forEach((item, i) => traverse(item, { key: i, up: trail }));
+            return;
+        }
+        const record = node;
+        const keys = Object.keys(record);
+        index(record, keys, trail);
+        linkReferences(record, trail);
+        keys.forEach(key => traverse(record[key], { key, up: trail }));
+    };
+    traverse(edition, null);
+    return { paths, links };
+});
+/** Where the entity with the id stands in the edition, or nothing where it holds none. */
+export const pathIn = (edition, id) => {
+    const trail = placesIn(edition).paths.get(id);
+    return trail === undefined ? undefined : laidOut(trail);
+};
+/** Where the edition references the id. */
+export const linksTo = (edition, id) => (placesIn(edition).links.get(id) ?? []).map(laidOut);

package/lib/lookup/perState.d.ts

@@ -0,0 +1,32 @@
+import { Draft } from "immer";
+/**
+ * The draft as it stands, as plain data: the state it was drafted from
+ * while nothing has changed it, and a copy of it as it now stands once
+ * something has.
+ */
+export declare const takenOf: <T extends object>(draft: Draft<T>) => T;
+/**
+ * The edition as a state that no longer changes. It is frozen, deeply
+ * and once, as immer freezes what it produces, since what is worked out
+ * from a state is kept for as long as the state is: changed in place
+ * afterwards, it would leave that behind unnoticed, and frozen, the
+ * change throws instead. An edition immer produced is frozen already,
+ * and freezing stops at whatever is. A copy taken of a draft is left as
+ * it is (`takenOf`).
+ *
+ * A draft is no such state, since the next write changes it. It is read
+ * as it stands by taking `stateOf(draft)` first, once for all that is
+ * asked of it; asked of directly, it would have to be copied for every
+ * question.
+ */
+export declare const settled: <T extends object>(edition: T) => T;
+/**
+ * What is worked out from an edition, once for each state of it.
+ *
+ * Every change to an edition yields a new object, immer's produce
+ * included, so the state an object stands for never changes and what
+ * was worked out from it holds for as long as the object is around.
+ * Nothing is worked out before it is first asked for, and nothing is
+ * kept once the state is gone.
+ */
+export declare const perState: <E extends object, T>(work: (edition: E) => T) => ((edition: E) => T);

package/lib/lookup/perState.js

@@ -0,0 +1,63 @@
+import { current, freeze, isDraft, original } from "immer";
+/**
+ * Copies taken of a draft as it stood, for an operation to read. Such a
+ * copy is the operation's alone and is not frozen: what the operation
+ * reads from it may go into the draft, and a later operation on the same
+ * draft may go on to change it there, as it may anything written there.
+ */
+const takenOfDrafts = new WeakSet();
+/**
+ * The draft as it stands, as plain data: the state it was drafted from
+ * while nothing has changed it, and a copy of it as it now stands once
+ * something has.
+ */
+export const takenOf = (draft) => {
+    const state = current(draft);
+    if (state !== original(draft))
+        takenOfDrafts.add(state);
+    return state;
+};
+/**
+ * The edition as a state that no longer changes. It is frozen, deeply
+ * and once, as immer freezes what it produces, since what is worked out
+ * from a state is kept for as long as the state is: changed in place
+ * afterwards, it would leave that behind unnoticed, and frozen, the
+ * change throws instead. An edition immer produced is frozen already,
+ * and freezing stops at whatever is. A copy taken of a draft is left as
+ * it is (`takenOf`).
+ *
+ * A draft is no such state, since the next write changes it. It is read
+ * as it stands by taking `stateOf(draft)` first, once for all that is
+ * asked of it; asked of directly, it would have to be copied for every
+ * question.
+ */
+export const settled = (edition) => {
+    if (isDraft(edition)) {
+        throw new Error('An edition is asked about as a state, not as a draft: take stateOf(draft) first.');
+    }
+    return takenOfDrafts.has(edition) ? edition : freeze(edition, true);
+};
+/**
+ * What is worked out from an edition, once for each state of it.
+ *
+ * Every change to an edition yields a new object, immer's produce
+ * included, so the state an object stands for never changes and what
+ * was worked out from it holds for as long as the object is around.
+ * Nothing is worked out before it is first asked for, and nothing is
+ * kept once the state is gone.
+ */
+export const perState = (work) => {
+    const known = new WeakMap();
+    return edition => {
+        // A state known already was settled when it became known, and a
+        // draft never is, so only what is asked of for the first time
+        // needs settling.
+        const kept = known.get(edition);
+        if (kept)
+            return kept.value;
+        const state = settled(edition);
+        const entry = { value: work(state) };
+        known.set(state, entry);
+        return entry.value;
+    };
+};

package/lib/model/Assumption.d.ts

@@ -46,22 +46,35 @@ export interface Inference extends Argumentation<'inference'> {
     /**
      * References (by `@id`) to the beliefs
      * from which the conclusion is drawn.
+     *
+     * A belief the editor holds and publishes elsewhere under an IRI of
+     * its own, such as a bound from a catalogue of premises the editor
+     * keeps, is named by that IRI. Someone else's belief is not: it is
+     * adopted first, and the belief of the edition's own that the
+     * adoption concludes is named instead.
      * @see crminf:J1 used as premise
      */
     premises: string[];
     /**
      * References (by `@id`) to what the inference worked on besides
-     * beliefs, such as the versions it compared or the analysis output
-     * it cites.
+     * beliefs, such as the versions it compared, the analysis output it
+     * cites, or the document holding a premise named by IRI, in the
+     * state it was read in, since a belief published elsewhere may move
+     * after the edition has used it.
      * @see crm:P16 used specific object
      */
     used?: string[];
 }
 /**
- * A belief adoption adopts someone else's belief. This type is used
- * to indicate e.g. knowledge through private communication or
- * from secondary literature, or a belief published elsewhere under
- * an IRI of its own, such as a premise from a catalogue of premises.
+ * A belief adoption takes over someone else's belief without checking it:
+ * knowledge through private communication, from the secondary
+ * literature, or from another edition. Like every reason, it concludes
+ * the belief it is a reason of, which is the edition's own and holds of
+ * the edition's statement what the adopted belief held. An inference that
+ * relies on it names that belief among its premises.
+ *
+ * The editor's own beliefs need no adoption, wherever they are
+ * published: an inference names them directly (see `Inference`).
  * @see crminf:I7 Belief Adoption
  */
 export interface BeliefAdoption extends Argumentation<'beliefAdoption'> {
@@ -76,9 +89,8 @@ export interface BeliefAdoption extends Argumentation<'beliefAdoption'> {
     note: string;
     /**
      * The beliefs this adoption takes over, by IRI, where they are
-     * published with one. An inference that uses such a belief names it
-     * among its premises by the same IRI; the adoption says where it
-     * comes from.
+     * published with one. They are someone else's, and stay theirs: what
+     * the edition holds is the belief the adoption concludes.
      * @see crminf:J6 adopted
      */
     adopted?: string[];

package/lib/model/Edit.d.ts

@@ -23,6 +23,10 @@ export type EditType = typeof editTypes[number];
  * If an edit is the interpretation of a metamark,
  * such as a pencil mark, this should be made explicit
  * using a meaning comprehension on the `@annotation` field.
+ * An edit states no date. That it ended no later than the act that
+ * made a feature carrying a symbol it inserts, a reasoner derives with
+ * the axioms of reo.ttl; which of those dates bounds it closest is for
+ * a query to pick.
  * @see reo:Edit
  */
 export interface Edit extends WithId, Assumption {

package/lib/model/Edition.d.ts

@@ -140,6 +140,18 @@ export interface Edition {
      * @see reo:witness
      */
     copies: RollCopy[];
+    /**
+     * The copy whose millimetres are the edition's axis, by id: every
+     * place the edition gives along the roll is a place on this copy's
+     * paper, counted from where its scan begins, and every other copy is
+     * aligned onto it. Choosing it is the one editorial decision the
+     * alignment leaves; a copy scanned whole and without tears serves
+     * best, since its places are what notes and readers cite. Left out,
+     * it is the first copy with features that is not aligned
+     * (`referenceCopyOf`).
+     * Not exported to RDF.
+     */
+    referenceCopy?: string;
     /**
      * The different versions of the roll on which
      * this edition is based.
@@ -154,3 +166,10 @@ export interface Edition {
     tempoAdjustment?: ObjectAssumption<RollTempo>;
 }
 export type EditionMetadata = Pick<Edition, 'base' | 'title' | 'license' | 'creation' | 'roll'>;
+/**
+ * The copy whose millimetres are the edition's axis: the one it names,
+ * or where it names none or one it no longer has, the first copy with
+ * features that is not aligned, which is how an edition stood before it
+ * named one.
+ */
+export declare const referenceCopyOf: (edition: Pick<Edition, 'copies' | 'referenceCopy'>) => RollCopy | undefined;

package/lib/model/Edition.js

@@ -1 +1,9 @@
-export {};
+import { featuresOf } from "./RollCopy.js";
+/**
+ * The copy whose millimetres are the edition's axis: the one it names,
+ * or where it names none or one it no longer has, the first copy with
+ * features that is not aligned, which is how an edition stood before it
+ * named one.
+ */
+export const referenceCopyOf = (edition) => edition.copies.find(copy => copy.id === edition.referenceCopy)
+    ?? edition.copies.find(copy => !copy.measurements.alignment && featuresOf(copy).length > 0);

package/lib/model/Quantity.d.ts

@@ -11,7 +11,7 @@ declare const unit: unique symbol;
  * The units a record may state. A `Measure` is limited to these, since
  * they are what the `unit` field is allowed to say.
  */
-export type Unit = 'mm' | 'cm' | 'px' | 'track' | 's' | 'ms' | 'ft/min' | 'm/min' | 'px/in' | 'deg';
+export type Unit = 'mm' | 'cm' | 'px' | 'track' | 's' | 'ms' | 'ft/min' | 'm/min' | 'px/in' | 'deg' | 'percent';
 export type Quantity<U extends string> = number & {
     readonly [unit]: U;
 };
@@ -30,6 +30,8 @@ export type MetersPerMinute = Quantity<'m/min'>;
 export type Resolution = Quantity<'px/in'>;
 /** An angle on the roll, turning from the line across the paper towards the end of the roll. */
 export type Degrees = Quantity<'deg'>;
+/** A share of a length, such as how far the paper has stretched: dimensionless, in hundredths. */
+export type Percent = Quantity<'percent'>;
 /** Names a number in a unit. Partially apply it to make a constructor. */
 export declare const quantity: <U extends string>(value: number) => Quantity<U>;
 export declare const mm: (value: number) => Quantity<"mm">;
@@ -42,6 +44,7 @@ export declare const feetPerMinute: (value: number) => Quantity<"ft/min">;
 export declare const metersPerMinute: (value: number) => Quantity<"m/min">;
 export declare const pixelsPerInch: (value: number) => Quantity<"px/in">;
 export declare const degrees: (value: number) => Quantity<"deg">;
+export declare const percent: (value: number) => Quantity<"percent">;
 /**
  * A value together with the unit it was measured in, as a record
  * states it.

package/lib/model/Quantity.js

@@ -10,6 +10,7 @@ export const feetPerMinute = quantity;
 export const metersPerMinute = quantity;
 export const pixelsPerInch = quantity;
 export const degrees = quantity;
+export const percent = quantity;
 // The second operand takes its unit from the first. Inferred from both,
 // TypeScript would unite two units rather than reject them.
 export const add = (a, b) => quantity(a + b);