linked-rolls 0.62.0 → 0.63.0

package/lib/collation/alignment.js

@@ -1,56 +1,126 @@
-import { featuresOf } from "../model/RollCopy.js";
+import { featuresOf, isTear, tearsOf } from "../model/RollCopy.js";
 import { defaultTrackerBar } from "../systems/index.js";
-import { add, mm, scale, subtract } from "../model/Quantity.js";
-/** Moves both ends of a span, the far end only where the span has one. */
-const move = (span, by) => {
-    span.from = add(span.from, by);
+import { add, mm, subtract, track } from "../model/Quantity.js";
+/** A place on the copy's own paper, on the edition's axis. */
+export const toAxis = (alignment) => (place) => alignment ? mm((place + alignment.shift.horizontal) * alignment.scale) : place;
+/** A place on the edition's axis, on the copy's own paper. */
+export const fromAxis = (alignment) => (place) => alignment ? mm(place / alignment.scale - alignment.shift.horizontal) : place;
+const acrossToAxis = (alignment) => (position) => alignment ? track(position + alignment.shift.vertical) : position;
+const acrossFromAxis = (alignment) => (position) => alignment ? track(position - alignment.shift.vertical) : position;
+/** Both ends of a span taken through the mapping, the far end only where the span has one. */
+const mapped = (span, through) => {
+    span.from = through(span.from);
     if (span.to !== undefined)
-        span.to = add(span.to, by);
+        span.to = through(span.to);
 };
-/** Stretches both ends of a span away from the beginning of the roll. */
-const stretch = (span, factor) => {
-    span.from = scale(span.from, factor);
-    if (span.to !== undefined)
-        span.to = scale(span.to, factor);
+/**
+ * Where along the roll the copy states anything: its features, and its
+ * tears, which are measured as the features are. A tear states no track,
+ * so the shift across the roll leaves it where it is.
+ */
+const spansAlong = (copy) => [...featuresOf(copy), ...tearsOf(copy)].map(placed => placed.horizontal);
+/** Puts the copy's own places onto the axis in place. */
+const moveOnto = (alignment, copy) => {
+    spansAlong(copy).forEach(span => mapped(span, toAxis(alignment)));
+    featuresOf(copy).forEach(feature => mapped(feature.vertical, acrossToAxis(alignment)));
 };
-const back = (shift) => ({ horizontal: scale(shift.horizontal, -1), vertical: scale(shift.vertical, -1) });
-export const applyShift = (shift, copy) => {
-    if (copy.measurements.shift)
-        return;
-    featuresOf(copy).forEach(feature => {
-        move(feature.horizontal, shift.horizontal);
-        move(feature.vertical, shift.vertical);
-    });
-    copy.measurements.shift = shift;
+/** Takes the copy's places on the axis back to its own paper in place. */
+const moveOff = (alignment, copy) => {
+    spansAlong(copy).forEach(span => mapped(span, fromAxis(alignment)));
+    featuresOf(copy).forEach(feature => mapped(feature.vertical, acrossFromAxis(alignment)));
 };
-/** Scales the copy's features away from the beginning of the roll, and records the factor. */
-export const applyScale = (factor, copy) => {
-    if (copy.measurements.scale !== undefined)
-        return;
-    featuresOf(copy).forEach(feature => stretch(feature.horizontal, factor));
-    copy.measurements.scale = factor;
+/**
+ * Carries the copy's features and tears from its own places onto the
+ * axis, and records how, in place of any alignment it had: that one is
+ * taken off first.
+ */
+export const applyAlignment = (alignment, copy) => {
+    revertAlignment(copy);
+    moveOnto(alignment, copy);
+    copy.measurements.alignment = alignment;
 };
-/** Takes the shift off the copy's features again, as far as one was applied. */
-export const revertShift = (copy) => {
-    const shift = copy.measurements.shift;
-    if (!shift)
+/** Takes the copy's features and tears back to its own places, as far as it was aligned. */
+export const revertAlignment = (copy) => {
+    const alignment = copy.measurements.alignment;
+    if (!alignment)
         return;
-    const reversed = back(shift);
-    featuresOf(copy).forEach(feature => {
-        move(feature.horizontal, reversed.horizontal);
-        move(feature.vertical, reversed.vertical);
-    });
-    delete copy.measurements.shift;
+    moveOff(alignment, copy);
+    delete copy.measurements.alignment;
 };
-/** Takes the scale off the copy's features again, as far as one was applied. */
-export const revertScale = (copy) => {
-    const factor = copy.measurements.scale;
-    if (factor === undefined)
-        return;
-    featuresOf(copy).forEach(feature => stretch(feature.horizontal, 1 / factor));
-    delete copy.measurements.scale;
+/**
+ * Places are written to the nanometre. Carried onto the axis and back,
+ * a place comes back a rounding error away from where it was, and a
+ * document saved again would change in its last digits every time.
+ * A scan resolves a tenth of a millimetre at best.
+ */
+const PLACES_PER_MM = 1e6;
+const written = (place) => mm(Math.round(place * PLACES_PER_MM) / PLACES_PER_MM);
+/**
+ * The copy with its features and tears at its own places, as a document
+ * holds them, and its alignment kept to say how they go onto the axis.
+ * The copy given is left as it is. A copy that is not aligned is the
+ * very same copy.
+ */
+export const atOwnPlaces = (copy) => {
+    const alignment = copy.measurements.alignment;
+    if (!alignment)
+        return copy;
+    const along = (place) => written(fromAxis(alignment)(place));
+    const across = acrossFromAxis(alignment);
+    const ownSpan = (span, through) => {
+        const own = { ...span };
+        mapped(own, through);
+        return own;
+    };
+    const ownFeature = (feature) => ({ ...feature, horizontal: ownSpan(feature.horizontal, along), vertical: ownSpan(feature.vertical, across) });
+    return {
+        ...copy,
+        ...(copy.production && {
+            production: {
+                ...copy.production,
+                ...(copy.production.produced && { produced: copy.production.produced.map(ownFeature) })
+            }
+        }),
+        modifications: copy.modifications.map(act => {
+            if (act.type === 'Alteration')
+                return { ...act, produced: act.produced.map(ownFeature) };
+            if (act.type === 'Attachment')
+                return { ...act, added: act.added.map(ownFeature) };
+            return act;
+        }),
+        conditions: copy.conditions.map(condition => isTear(condition)
+            ? { ...condition, horizontal: ownSpan(condition.horizontal, along) }
+            : condition)
+    };
+};
+/**
+ * Puts the features and tears of a copy read from a document, which
+ * holds them at the copy's own places, onto the axis. The copy given is
+ * changed.
+ */
+export const putOnAxis = (copy) => {
+    const alignment = copy.measurements.alignment;
+    if (alignment)
+        moveOnto(alignment, copy);
+};
+/** The copy's features at its own places, as it was read, whatever alignment it has. */
+export const ownFeaturesOf = (copy) => {
+    const alignment = copy.measurements.alignment;
+    if (!alignment)
+        return featuresOf(copy);
+    return featuresOf(copy).map(feature => {
+        const own = { ...feature, horizontal: { ...feature.horizontal }, vertical: { ...feature.vertical } };
+        mapped(own.horizontal, fromAxis(alignment));
+        mapped(own.vertical, acrossFromAxis(alignment));
+        return own;
+    });
 };
 const chainsOf = (copy) => featuresOf(copy).filter(feature => feature.type === 'HoleChain');
+/**
+ * The reader's extension as it lies on the axis. It is a length on the
+ * copy's own paper, which the alignment scales like any other.
+ */
+const extensionOnAxis = (extension, copy) => mm(extension * (copy.measurements.alignment?.scale ?? 1));
 /**
  * Takes the extension a pneumatic reader adds off the ends of the
  * copy's chains of holes, and records how much was taken.
@@ -86,7 +156,10 @@ const chainsOf = (copy) => featuresOf(copy).filter(feature => feature.type === '
  * on the feature, a reading of the chain, a smaller extension — and
  * `shortenChains` throws rather than answer it.
  */
-export const tooShortToShorten = (extension, copy, leaving = new Set()) => chainsOf(copy).filter(chain => !leaving.has(chain.id) && chain.horizontal.to - chain.horizontal.from <= extension);
+export const tooShortToShorten = (extension, copy, leaving = new Set()) => {
+    const onAxis = extensionOnAxis(extension, copy);
+    return chainsOf(copy).filter(chain => !leaving.has(chain.id) && chain.horizontal.to - chain.horizontal.from <= onAxis);
+};
 /**
  * Takes the extension off, leaving the named chains as the reader gave
  * them. Naming a chain is an editorial act and not a repair: it says
@@ -107,10 +180,11 @@ export const shortenChains = (extension, copy, leaving = new Set()) => {
             + `chain(s) of holes of copy ${copy.id}, which are no longer than it: `
             + `${tooShort.map(chain => chain.id).join(', ')}`);
     }
+    const onAxis = extensionOnAxis(extension, copy);
     const left = chainsOf(copy).filter(chain => leaving.has(chain.id)).map(chain => chain.id);
     chainsOf(copy)
         .filter(chain => !leaving.has(chain.id))
-        .forEach(chain => { chain.horizontal.to = subtract(chain.horizontal.to, extension); });
+        .forEach(chain => { chain.horizontal.to = subtract(chain.horizontal.to, onAxis); });
     copy.measurements.readerExtension = { length: extension, ...(left.length > 0 && { leaving: left }) };
 };
 /** Puts the reader's extension back on the chains it was taken off, as far as one was taken off. */
@@ -118,12 +192,20 @@ export const revertShortening = (copy) => {
     const taken = copy.measurements.readerExtension;
     if (taken === undefined)
         return;
+    const onAxis = extensionOnAxis(taken.length, copy);
     const left = new Set(taken.leaving ?? []);
     chainsOf(copy)
         .filter(chain => !left.has(chain.id))
-        .forEach(chain => { chain.horizontal.to = add(chain.horizontal.to, taken.length); });
+        .forEach(chain => { chain.horizontal.to = add(chain.horizontal.to, onAxis); });
     delete copy.measurements.readerExtension;
 };
+/**
+ * The method `alignFeatures` follows, as an alignment records it. Its
+ * revision changes when the method does and at no other release, so
+ * that an alignment found by an earlier method can be told from one
+ * that would be found again as it stands.
+ */
+export const ALIGNMENT_METHOD = { software: 'linked-rolls alignFeatures', version: '1' };
 const byPlace = (x, y) => x.at - y.at || x.pitch - y.pitch;
 /** The notes the bar reads off the features, in the order they pass it. */
 const noteOnsets = (features, bar) => features
@@ -218,15 +300,23 @@ const settled = (a, b) => (fit, window) => {
     const matches = nearestMatches(a, b, fit.line, window);
     return { line: robustLine(matches) ?? fit.line, matches };
 };
+/** How far the places of the matches on the copy spread, as a standard deviation. */
+const spreadOf = (matches) => {
+    const centre = matches.reduce((total, m) => total + m.a, 0) / matches.length;
+    return Math.sqrt(matches.reduce((total, m) => total + (m.a - centre) ** 2, 0) / matches.length);
+};
 const resultOf = ({ line, matches }) => {
     if (matches.length < 2 || line.slope <= 0)
         return undefined;
     const squares = matches.reduce((total, m) => total + residualOf(line, m) ** 2, 0);
+    const residual = Math.sqrt(squares / matches.length);
+    const spread = spreadOf(matches);
     return {
         shift: mm(line.intercept / line.slope),
         scale: line.slope,
         matched: matches.length,
-        residual: mm(Math.sqrt(squares / matches.length))
+        residual: mm(residual),
+        scaleError: spread > 0 ? residual / (spread * Math.sqrt(matches.length)) : Infinity
     };
 };
 /**

package/lib/index.d.ts

@@ -28,11 +28,12 @@ export * from './model/procedures.js';
 export * from './model/vocabulary.js';
 export * from './analysis/reservations.js';
 export * from './analysis/witnesses.js';
-export { alignFeatures, tooShortToShorten, type AlignmentResult } from './collation/alignment.js';
+export { alignFeatures, ALIGNMENT_METHOD, fromAxis, ownFeaturesOf, toAxis, tooShortToShorten, type AlignmentResult } from './collation/alignment.js';
 export * from './collation/statistics.js';
 export * from './model/Edition.js';
 export * from './view/EditionView.js';
 export * from './analysis/ownPaper.js';
+export * from './analysis/paper.js';
 export * from './emulation/negotiation.js';
 export * from './collation/scatter.js';
 export * from './ops/index.js';

package/lib/index.js

@@ -21,11 +21,12 @@ export * from './model/procedures.js';
 export * from './model/vocabulary.js';
 export * from './analysis/reservations.js';
 export * from './analysis/witnesses.js';
-export { alignFeatures, tooShortToShorten } from './collation/alignment.js';
+export { alignFeatures, ALIGNMENT_METHOD, fromAxis, ownFeaturesOf, toAxis, tooShortToShorten } from './collation/alignment.js';
 export * from './collation/statistics.js';
 export * from './model/Edition.js';
 export * from './view/EditionView.js';
 export * from './analysis/ownPaper.js';
+export * from './analysis/paper.js';
 export * from './emulation/negotiation.js';
 export * from './collation/scatter.js';
 export * from './ops/index.js';

package/lib/io/asJsonLd.js

@@ -1,6 +1,7 @@
 import { systemIdIn } from "../systems/TrackerBar.js";
 import { certaintyOf, isAsserted } from "../model/Assumption.js";
 import context from "../spec/context.json" with { type: 'json' };
+import { atOwnPlaces } from "../collation/alignment.js";
 /**
  * The keys an export derives from the tree, which no node of the
  * edition states itself. An import reads them off again.
@@ -151,8 +152,12 @@ const withDoubtedReferencesQuoted = (value) => {
         quoted: entries.flatMap(({ quoted }) => quoted)
     };
 };
+/** The edition with each copy's features and tears at the copy's own places, as a document holds them. */
+const atOwnPlacesAll = (edition) => edition.copies.some(copy => copy.measurements.alignment)
+    ? { ...edition, copies: edition.copies.map(atOwnPlaces) }
+    : edition;
 export const asJsonLd = (edition) => {
-    const { node, quoted } = withDoubtedReferencesQuoted(withSystemContexts(withChanges(asJsonLdEntity(edition))));
+    const { node, quoted } = withDoubtedReferencesQuoted(withSystemContexts(withChanges(asJsonLdEntity(atOwnPlacesAll(edition)))));
     // The context is the export's own; one carried in from an import must not override it.
     const { base, '@context': carried, ...rest } = node;
     return {

package/lib/io/importJsonLd.d.ts

@@ -1,5 +1,10 @@
 import { Edition } from "../model/Edition.js";
 export declare const importDate: (str: string) => Date;
 type Json = any;
+/**
+ * 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 declare const importJsonLd: (json: Json) => Edition;
 export {};

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));
@@ -118,11 +119,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 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/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/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);