linked-rolls 0.63.0 → 0.64.0

package/lib/collation/scatter.js

@@ -4,12 +4,14 @@ import { mean, mm } from "../model/Quantity.js";
 import { excessKurtosisOf, histogramOf, normalQuantile, spreadOf, standardise, tailOf } from "./statistics.js";
 import { groupBy } from "../shared/utils.js";
 import { deletedBy, insertedBy } from "../model/Version.js";
+import { carriersOf, placedCarriersOf, snapshotOf } from "../analysis/text.js";
+import { copyOfFeature, symbolsIn, versionIn } from "../lookup/lookup.js";
 const placeOf = (carriers) => ({
     from: mean(carriers.map(carrier => carrier.horizontal.from)),
     to: mean(carriers.map(carrier => carrier.horizontal.to))
 });
-const sitsOn = (view, copies) => (feature) => {
-    const copy = view.copyOf(feature.id);
+const sitsOn = (edition, copies) => (feature) => {
+    const copy = copyOfFeature(edition, feature.id);
     return copy !== undefined && copies.has(copy.id);
 };
 /**
@@ -34,10 +36,10 @@ const sitsOn = (view, copies) => (feature) => {
  * A symbol only one side carries measures nothing and is passed over,
  * which leaves out exactly the insertions and the deletions.
  */
-export const readingsOf = (view, symbols, copies) => {
-    const tested = sitsOn(view, copies);
+export const readingsOf = (edition, symbols, copies) => {
+    const tested = sitsOn(edition, copies);
     return symbols.flatMap((symbol) => {
-        const carriers = view.placedCarriersOf(symbol);
+        const carriers = placedCarriersOf(edition, symbol);
         const here = carriers.filter(tested);
         const there = carriers.filter(carrier => !tested(carrier));
         if (here.length === 0 || there.length === 0)
@@ -120,7 +122,7 @@ const scatterIn = (group, sample, { binWidth = DEFAULT_BIN_WIDTH, stated }) => {
 export const scatterOf = (readings, options = {}) => [...groupBy(readings, reading => (options.groupOf ?? byWhatItIs)(reading.symbol))]
     .flatMap(([group, sample]) => scatterIn(group, sample, options));
 /** How one copy's readings of a version's text scatter against the readings of the copies it is collated with. */
-export const scatterOfCopy = (view, versionId, copyId, options = {}) => scatterOf(readingsOf(view, view.snapshot(versionId), new Set([copyId])), options);
+export const scatterOfCopy = (edition, versionId, copyId, options = {}) => scatterOf(readingsOf(edition, snapshotOf(edition, versionId), new Set([copyId])), options);
 const covering = (windows) => {
     const lowest = Math.min(...windows.map(window => window.offset - window.tolerance));
     const highest = Math.max(...windows.map(window => window.offset + window.tolerance));
@@ -189,10 +191,10 @@ export const changesBetween = (readings, inForce, proposed) => ({
     separated: readings.filter(({ displacement }) => admits(inForce, displacement) && !admits(proposed, displacement)),
     merged: readings.filter(({ displacement }) => !admits(inForce, displacement) && admits(proposed, displacement))
 });
-const copiesBearing = (view, symbols) => {
+const copiesBearing = (edition, symbols) => {
     const tally = symbols.reduce((counts, symbol) => {
-        const bearers = new Set(view.carriersOf(symbol).flatMap(carrier => {
-            const copy = view.copyOf(carrier.id);
+        const bearers = new Set(carriersOf(edition, symbol).flatMap(carrier => {
+            const copy = copyOfFeature(edition, carrier.id);
             return copy ? [copy.id] : [];
         }));
         bearers.forEach(copy => counts.set(copy, (counts.get(copy) ?? 0) + 1));
@@ -219,13 +221,13 @@ const copiesBearing = (view, symbols) => {
  * neither side, which is the case where the edition has genuinely
  * stopped saying and an editor has to.
  */
-export const sidesOf = (view, versionId) => {
-    const version = view.version(versionId);
+export const sidesOf = (edition, versionId) => {
+    const version = versionIn(edition, versionId);
     if (!version)
         return undefined;
     return {
-        child: copiesBearing(view, insertedBy(version)),
-        parent: copiesBearing(view, view.symbols(deletedBy(version)))
+        child: copiesBearing(edition, insertedBy(version)),
+        parent: copiesBearing(edition, symbolsIn(edition, deletedBy(version)))
     };
 };
 const inMillimetres = (value) => `${value.toFixed(2)} mm`;

package/lib/emulation/Emulation.d.ts

@@ -1,9 +1,9 @@
 import { MidiFile } from "midifile-ts";
-import { EditionView } from "../view/EditionView.js";
 import type { TrackerBar } from "../systems/TrackerBar.js";
 import { Version } from "../model/Version.js";
 import { AnyPerformedRollFeature, EmulatedCurve, NegotiatedEvent, ReproducingSystem } from "../systems/ReproducingSystem.js";
 import { Millimeters } from "../model/Quantity.js";
+import { Edition } from "../model/Edition.js";
 export type EmulationScope = {
     /** Only notes whose onset lies within this span of the roll are played. */
     range?: [Millimeters, Millimeters];
@@ -12,17 +12,17 @@ export type EmulationScope = {
 };
 /**
  * The events moved to where their statements put them, the events given
- * left as they were. The view supplies the copies, whose measurements
+ * left as they were. The edition supplies the copies, whose measurements
  * decide how far before or after its reference a command goes, and a
  * punch diameter, or a millimetre, where no copy agrees with a statement.
  */
-export declare const withPlacementsApplied: (view: EditionView, events: readonly NegotiatedEvent[]) => NegotiatedEvent[];
+export declare const withPlacementsApplied: (edition: Edition, events: readonly NegotiatedEvent[]) => NegotiatedEvent[];
 /**
  * The commands of a version as the bar performs them, in order of place,
  * within the scope and with the placements applied. A note plays only
  * where its onset falls in the range; expressions play throughout.
  */
-export declare const negotiatedEventsOf: (view: EditionView, version: Readonly<Version>, bar: TrackerBar, { range }?: Pick<EmulationScope, 'range'>) => NegotiatedEvent[];
+export declare const negotiatedEventsOf: (edition: Edition, version: Readonly<Version>, bar: TrackerBar, { range }?: Pick<EmulationScope, 'range'>) => NegotiatedEvent[];
 /** A version performed: what was negotiated, and what the system made of it. */
 export interface Emulated {
     /** The id of the version performed. */
@@ -36,7 +36,7 @@ export interface Emulated {
  * Performs a version on a reproducing system: the symbols are negotiated
  * into placed events and the system plays them. Nothing given is changed.
  */
-export declare const emulate: <Options extends object>(system: ReproducingSystem<Options>, version: Readonly<Version>, view: EditionView, options?: Options, { range, skipToFirstNote }?: EmulationScope) => Emulated;
+export declare const emulate: <Options extends object>(system: ReproducingSystem<Options>, version: Readonly<Version>, edition: Edition, options?: Options, { range, skipToFirstNote }?: EmulationScope) => Emulated;
 /**
  * The performed events as a MIDI file, in which every note and pedal step
  * is labelled with the symbol it performs. The file names the system, the
@@ -57,8 +57,8 @@ export declare class Emulation<Options extends object> {
     source?: string;
     constructor(system: ReproducingSystem<Options>, options?: Options);
     /** Moves the negotiated events to where their statements put them; see `withPlacementsApplied`. */
-    applyConstraints(view: EditionView): void;
-    emulateVersion(version: Version, view: EditionView, scope?: EmulationScope): AnyPerformedRollFeature[];
+    applyConstraints(edition: Edition): void;
+    emulateVersion(version: Version, edition: Edition, scope?: EmulationScope): AnyPerformedRollFeature[];
     findEventsPerforming(id: string): AnyPerformedRollFeature[];
     asMIDI(): MidiFile;
 }

package/lib/emulation/Emulation.js

@@ -5,25 +5,27 @@ import { add, mean, mm, seconds, subtract } from "../model/Quantity.js";
 import { punchDiameterOf } from "../model/RollCopy.js";
 import { toOwnPaperOf } from "../analysis/ownPaper.js";
 import { negotiatedEventOf } from "./negotiation.js";
+import { placedCarriersOf, snapshotOf } from "../analysis/text.js";
+import { copyOfFeature, symbolIn } from "../lookup/lookup.js";
 /** The punch diameter the edition's copies report, where any of them does. */
-const meanPunchDiameterOf = (view) => {
-    const measured = view.edition.copies
+const meanPunchDiameterOf = (edition) => {
+    const measured = edition.copies
         .map(punchDiameterOf)
         .filter(value => value !== undefined);
     return measured.length > 0 ? mean(measured) : undefined;
 };
-const propertiesOf = (view, version) => ({
-    punchDiameter: meanPunchDiameterOf(view),
-    tempo: view.edition.tempoAdjustment,
-    toOwnPaper: toOwnPaperOf(view, version)
+const propertiesOf = (edition, version) => ({
+    punchDiameter: meanPunchDiameterOf(edition),
+    tempo: edition.tempoAdjustment,
+    toOwnPaper: toOwnPaperOf(edition, version)
 });
 /** The onset a symbol has on each copy carrying it, by the copy's id, as the mean of its chains there. */
-const onsetsByCopy = (view, symbolId) => {
-    const symbol = view.symbol(symbolId);
+const onsetsByCopy = (edition, symbolId) => {
+    const symbol = symbolIn(edition, symbolId);
     if (!symbol)
         return new Map();
-    const onsets = view.placedCarriersOf(symbol).flatMap((carrier) => {
-        const copy = view.copyOf(carrier.id);
+    const onsets = placedCarriersOf(edition, symbol).flatMap((carrier) => {
+        const copy = copyOfFeature(edition, carrier.id);
         return copy ? [[copy.id, carrier.horizontal.from]] : [];
     });
     const copies = new Set(onsets.map(([copy]) => copy));
@@ -34,9 +36,9 @@ const onsetsByCopy = (view, symbolId) => {
  * the follower on each copy carrying both, negative where the follower
  * comes first there.
  */
-const offsetsBetween = (view, followerId, referenceId) => {
-    const references = onsetsByCopy(view, referenceId);
-    return [...onsetsByCopy(view, followerId)].flatMap(([copy, onset]) => {
+const offsetsBetween = (edition, followerId, referenceId) => {
+    const references = onsetsByCopy(edition, referenceId);
+    return [...onsetsByCopy(edition, followerId)].flatMap(([copy, onset]) => {
         const reference = references.get(copy);
         return reference === undefined ? [] : [subtract(onset, reference)];
     });
@@ -91,13 +93,13 @@ const displacementsOf = (events, offsetsBetween, gap) => {
 const earliestOf = (times) => times.length === 0 ? seconds(0) : times.reduce((soonest, at) => at < soonest ? at : soonest);
 /**
  * The events moved to where their statements put them, the events given
- * left as they were. The view supplies the copies, whose measurements
+ * left as they were. The edition supplies the copies, whose measurements
  * decide how far before or after its reference a command goes, and a
  * punch diameter, or a millimetre, where no copy agrees with a statement.
  */
-export const withPlacementsApplied = (view, events) => {
-    const gap = meanPunchDiameterOf(view) ?? mm(1);
-    const offsets = (follower, reference) => offsetsBetween(view, follower, reference);
+export const withPlacementsApplied = (edition, events) => {
+    const gap = meanPunchDiameterOf(edition) ?? mm(1);
+    const offsets = (follower, reference) => offsetsBetween(edition, follower, reference);
     const displacements = displacementsOf(events, offsets, gap);
     return events.map(event => {
         const distance = displacements.get(event);
@@ -112,11 +114,11 @@ export const withPlacementsApplied = (view, events) => {
  * within the scope and with the placements applied. A note plays only
  * where its onset falls in the range; expressions play throughout.
  */
-export const negotiatedEventsOf = (view, version, bar, { range } = {}) => {
+export const negotiatedEventsOf = (edition, version, bar, { range } = {}) => {
     const inScope = (event) => !range || event.type !== 'note' || (event.horizontal.from > range[0] && event.horizontal.from < range[1]);
-    return withPlacementsApplied(view, view.snapshot(version.id)
+    return withPlacementsApplied(edition, snapshotOf(edition, version.id)
         .filter(isCommand)
-        .map(symbol => negotiatedEventOf(view, symbol, bar))
+        .map(symbol => negotiatedEventOf(edition, symbol, bar))
         .filter(event => event !== null)
         .filter(inScope));
 };
@@ -124,11 +126,11 @@ export const negotiatedEventsOf = (view, version, bar, { range } = {}) => {
  * Performs a version on a reproducing system: the symbols are negotiated
  * into placed events and the system plays them. Nothing given is changed.
  */
-export const emulate = (system, version, view, options = system.defaultOptions, { range, skipToFirstNote = false } = {}) => {
-    const negotiated = negotiatedEventsOf(view, version, system.trackerBar, { range });
+export const emulate = (system, version, edition, options = system.defaultOptions, { range, skipToFirstNote = false } = {}) => {
+    const negotiated = negotiatedEventsOf(edition, version, system.trackerBar, { range });
     if (negotiated.length === 0)
         return { source: version.id, negotiated, events: [], curves: [] };
-    const performance = system.perform(negotiated, options, propertiesOf(view, version));
+    const performance = system.perform(negotiated, options, propertiesOf(edition, version));
     const onsets = performance.events.filter(event => event.type === 'noteOn').map(event => event.at);
     const origin = skipToFirstNote ? earliestOf(onsets) : seconds(0);
     return {
@@ -262,11 +264,11 @@ export class Emulation {
         this.options = options;
     }
     /** Moves the negotiated events to where their statements put them; see `withPlacementsApplied`. */
-    applyConstraints(view) {
-        this.negotiatedEvents = withPlacementsApplied(view, this.negotiatedEvents);
+    applyConstraints(edition) {
+        this.negotiatedEvents = withPlacementsApplied(edition, this.negotiatedEvents);
     }
-    emulateVersion(version, view, scope = {}) {
-        const emulated = emulate(this.system, version, view, this.options, scope);
+    emulateVersion(version, edition, scope = {}) {
+        const emulated = emulate(this.system, version, edition, this.options, scope);
         this.source = emulated.source;
         this.negotiatedEvents = [...emulated.negotiated];
         this.curves = emulated.curves;

package/lib/emulation/negotiation.d.ts

@@ -1,7 +1,7 @@
-import type { EditionView } from "../view/EditionView.js";
 import type { Expression, Note } from "../model/Symbol.js";
 import type { TrackerBar } from "../systems/TrackerBar.js";
 import type { NegotiatedEvent } from "../systems/ReproducingSystem.js";
+import { Edition } from "../model/Edition.js";
 /**
  * The symbol as a performance needs it: where it lies, and the
  * position the performing bar reads it on.
@@ -11,4 +11,4 @@ import type { NegotiatedEvent } from "../systems/ReproducingSystem.js";
  * green version still inherits cannot be performed on a green
  * machine, and an edit has yet to say what took its place.
  */
-export declare const negotiatedEventOf: (view: EditionView, symbol: Note | Expression, bar: TrackerBar) => NegotiatedEvent | null;
+export declare const negotiatedEventOf: (edition: Edition, symbol: Note | Expression, bar: TrackerBar) => NegotiatedEvent | null;

package/lib/emulation/negotiation.js

@@ -1,3 +1,4 @@
+import { placeOf } from "../analysis/text.js";
 /**
  * The symbol as a performance needs it: where it lies, and the
  * position the performing bar reads it on.
@@ -7,8 +8,8 @@
  * green version still inherits cannot be performed on a green
  * machine, and an edit has yet to say what took its place.
  */
-export const negotiatedEventOf = (view, symbol, bar) => {
-    const horizontal = view.placeOf(symbol);
+export const negotiatedEventOf = (edition, symbol, bar) => {
+    const horizontal = placeOf(edition, symbol);
     const position = bar.positionOf(symbol);
     if (!horizontal || position === undefined)
         return null;

package/lib/index.d.ts

@@ -31,7 +31,10 @@ export * from './analysis/witnesses.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 './lookup/lookup.js';
+export * from './lookup/paths.js';
+export * from './analysis/stemma.js';
+export * from './analysis/text.js';
 export * from './analysis/ownPaper.js';
 export * from './analysis/paper.js';
 export * from './emulation/negotiation.js';

package/lib/index.js

@@ -24,7 +24,10 @@ export * from './analysis/witnesses.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 './lookup/lookup.js';
+export * from './lookup/paths.js';
+export * from './analysis/stemma.js';
+export * from './analysis/text.js';
 export * from './analysis/ownPaper.js';
 export * from './analysis/paper.js';
 export * from './emulation/negotiation.js';

package/lib/io/asJsonLd.js

@@ -59,6 +59,16 @@ const withSystemContext = (version) => {
     return system ? { '@context': `https://w3id.org/reo/${system}/context.jsonld`, ...version } : version;
 };
 const withSystemContexts = (edition) => Array.isArray(edition.versions) ? { ...edition, versions: edition.versions.map(withSystemContext) } : edition;
+/**
+ * Gives every version the act that made it, stating nothing of it where
+ * nothing is known. The axioms of reo.ttl order that act in time against
+ * the recording, the copies and the act that made the version it derives
+ * from, and a reasoner cannot place a node the graph lacks. An import
+ * drops it again where it states nothing.
+ */
+const withCreations = (edition) => Array.isArray(edition.versions)
+    ? { ...edition, versions: edition.versions.map((version) => version.creation ? version : { ...version, creation: {} }) }
+    : edition;
 const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
 /** The act with what it changed named: an attachment augments the copy, a removal diminishes it. */
 const changing = (copyId) => (act) => {
@@ -157,7 +167,7 @@ const atOwnPlacesAll = (edition) => edition.copies.some(copy => copy.measurement
     ? { ...edition, copies: edition.copies.map(atOwnPlaces) }
     : edition;
 export const asJsonLd = (edition) => {
-    const { node, quoted } = withDoubtedReferencesQuoted(withSystemContexts(withChanges(asJsonLdEntity(atOwnPlacesAll(edition)))));
+    const { node, quoted } = withDoubtedReferencesQuoted(withSystemContexts(withCreations(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.js

@@ -71,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. */
@@ -125,7 +135,7 @@ const withQuotedStatementsInPlace = (edition) => {
  * 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'] || ''

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/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/Version.d.ts

@@ -93,7 +93,13 @@ export interface Version extends WithId {
     basedOn?: Derivation[];
     /**
      * The act that made this version, where it is known: who carried it
-     * out, when, and by what rule.
+     * out, when, and by what rule. The export states the act for every
+     * version, stating nothing of it where nothing is known, so that the
+     * axioms of reo.ttl can place it in time: it started after the
+     * recording and the creation of every version it derives from had
+     * started, and ended no later than the punching of any copy carrying
+     * a symbol it added. A date stated here stands beside those; which of
+     * them bounds the act closest is for a query to pick.
      * @see lrmoo:R17i was created by
      */
     creation?: VersionCreation;