@mathscan/geometry-engine 0.1.0

package/dist/geometry/distance.d.cts

@@ -0,0 +1,9 @@
+import { Point } from './point.cjs';
+export declare function projectionParameter(point: Point, a: Point, b: Point): number | null;
+export declare function pointAlong(a: Point, b: Point, t: number): Point;
+export declare function closestPointOnLine(point: Point, a: Point, b: Point): Point;
+export declare function closestPointOnSegment(point: Point, a: Point, b: Point): Point;
+export declare function distancePointToLine(point: Point, a: Point, b: Point): number;
+export declare function distancePointToSegment(point: Point, a: Point, b: Point): number;
+export declare function distancePointToCircle(point: Point, center: Point, radius: number): number;
+export declare function closestPointOnCircle(point: Point, center: Point, radius: number): Point | null;

package/dist/geometry/distance.d.ts

@@ -0,0 +1,10 @@
+import { Point } from './point.js';
+export declare function projectionParameter(point: Point, a: Point, b: Point): number | null;
+export declare function pointAlong(a: Point, b: Point, t: number): Point;
+export declare function closestPointOnLine(point: Point, a: Point, b: Point): Point;
+export declare function closestPointOnSegment(point: Point, a: Point, b: Point): Point;
+export declare function distancePointToLine(point: Point, a: Point, b: Point): number;
+export declare function distancePointToSegment(point: Point, a: Point, b: Point): number;
+export declare function distancePointToCircle(point: Point, center: Point, radius: number): number;
+export declare function closestPointOnCircle(point: Point, center: Point, radius: number): Point | null;
+//# sourceMappingURL=distance.d.ts.map

package/dist/geometry/distance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distance.d.ts","sourceRoot":"","sources":["../../src/geometry/distance.ts"],"names":[],"mappings":"AAIA,OAAO,EAAmB,KAAK,KAAK,EAAE,MAAM,SAAS,CAAA;AAOrD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,CAmBnF;AAID,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,CAE/D;AAGD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAI1E;AAID,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAI7E;AAID,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,MAAM,CAE5E;AAKD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,MAAM,CAE/E;AAMD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEzF;AAOD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI,CAM9F"}

package/dist/geometry/entities/circle.d.cts

@@ -0,0 +1,36 @@
+import { CircleDefinition, ResolvedCircle } from '../entityModel.cjs';
+export declare const circleOperations: {
+    kind: "circle";
+    parents: (definition: CircleDefinition) => readonly [string, string];
+    resolve: (_definition: CircleDefinition, [center, through]: readonly import('../entityModel.cjs').ResolvedEntity[]) => {
+        kind: "circle";
+        center: {
+            x: number;
+            y: number;
+        };
+        radius: number;
+    } | null;
+    toShape: (resolved: ResolvedCircle) => {
+        shape: "circle";
+        center: {
+            x: number;
+            y: number;
+        };
+        radius: number;
+    };
+    toMeasured: (resolved: ResolvedCircle) => {
+        type: "circle";
+        center: {
+            x: number;
+            y: number;
+        };
+        radius: number;
+    };
+    distanceTo: (resolved: ResolvedCircle, at: {
+        x: number;
+        y: number;
+    }) => number;
+    describe: (definition: CircleDefinition, nameOf: (id: import('../entityModel.cjs').EntityId) => string) => string;
+    hitPriority: number;
+    identityKey: (definition: CircleDefinition) => string;
+};

package/dist/geometry/entities/circle.d.ts

@@ -0,0 +1,37 @@
+import { CircleDefinition, ResolvedCircle } from '../entityModel.js';
+export declare const circleOperations: {
+    kind: "circle";
+    parents: (definition: CircleDefinition) => readonly [string, string];
+    resolve: (_definition: CircleDefinition, [center, through]: readonly import('../entityModel.js').ResolvedEntity[]) => {
+        kind: "circle";
+        center: {
+            x: number;
+            y: number;
+        };
+        radius: number;
+    } | null;
+    toShape: (resolved: ResolvedCircle) => {
+        shape: "circle";
+        center: {
+            x: number;
+            y: number;
+        };
+        radius: number;
+    };
+    toMeasured: (resolved: ResolvedCircle) => {
+        type: "circle";
+        center: {
+            x: number;
+            y: number;
+        };
+        radius: number;
+    };
+    distanceTo: (resolved: ResolvedCircle, at: {
+        x: number;
+        y: number;
+    }) => number;
+    describe: (definition: CircleDefinition, nameOf: (id: import('../entityModel.js').EntityId) => string) => string;
+    hitPriority: number;
+    identityKey: (definition: CircleDefinition) => string;
+};
+//# sourceMappingURL=circle.d.ts.map

package/dist/geometry/entities/circle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circle.d.ts","sourceRoot":"","sources":["../../../src/geometry/entities/circle.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,gBAAgB,EAAoB,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAGxF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDiC,CAAA"}

package/dist/geometry/entities/index.d.cts

@@ -0,0 +1,60 @@
+import { EntityDefinition, EntityId, EntityKind, EntityRegistry, ResolvedEntity, ResolvedEntityOf, ShapeDescriptor } from '../entityModel.cjs';
+import { Point } from '../point.cjs';
+import { MeasuredObject } from '../../measure/geometryAdapter.cjs';
+export { intersectEntities, parameterOnEntity, pointOnEntity } from './relations.cjs';
+export declare const entityRegistry: EntityRegistry;
+/**
+ * Every kind the registry declares. Read off the registry rather than written
+ * out again, so a consumer that has to enumerate kinds — a snap that offers
+ * every locus, a toolbar that offers every construction — grows with it.
+ */
+export declare const entityKinds: readonly EntityKind[];
+/**
+ * Every kind but the point: the entities a position can lie *on*.
+ *
+ * A point is a location and the rest are loci, which is the one distinction
+ * that survives generalization — it is why `parameterAt` has no meaning for a
+ * point and why snapping asks these kinds and not that one.
+ */
+export declare const objectEntityKinds: readonly EntityKind[];
+/** Every entity `definition` is built on, in declaration order. */
+export declare function parentsOfDefinition(definition: EntityDefinition): readonly EntityId[];
+/**
+ * Evaluates `definition` against its already-resolved parents, which must be
+ * in the order `parentsOfDefinition()` gave. `null` means "not on screen".
+ *
+ * A caller that could not resolve every parent should not call this at all:
+ * passing a short list would silently slide the parents that did resolve into
+ * the wrong positions.
+ */
+export declare function resolveDefinition<D extends EntityDefinition>(definition: D, parents: readonly ResolvedEntity[]): ResolvedEntityOf<D['kind']> | null;
+/**
+ * The resolved form of `definition` against points that have already been
+ * resolved for the scene it belongs to — `null` when it is not on screen.
+ *
+ * For the consumers that hold a definition and a point map rather than a
+ * context: `hitTest()` and `computeSnap()` are handed a scene assembled by a
+ * renderer, and a preview scene has no context to ask. A caller holding an
+ * `IndexedGeometryContext` asks that instead, because its answers are cached
+ * and these are computed per call.
+ */
+export declare function resolveAgainstPoints(definition: EntityDefinition, points: ReadonlyMap<EntityId, Point>): ResolvedEntity | null;
+/** What a renderer draws. */
+export declare function shapeOfResolved(resolved: ResolvedEntity): ShapeDescriptor;
+/** The two-point reduction the measurement seam accepts, or null. */
+export declare function measuredOfResolved(resolved: ResolvedEntity): MeasuredObject | null;
+/** Distance to the drawn object, in math space. */
+export declare function distanceToResolved(resolved: ResolvedEntity, at: Point): number;
+/** Rank at equal distance, lower wins. */
+export declare function hitPriorityOf(kind: EntityKind): number;
+/** The key deciding whether two definitions are the same construction. */
+export declare function identityKeyOf(definition: EntityDefinition): string;
+/**
+ * One sentence saying what this entity is, for the semantic companion (M1b.3).
+ *
+ * `nameOf` resolves a parent id to the name that surface calls it — the
+ * renderer passes `entityDisplayName()`, so "segment from A to B" names the
+ * two points the canvas has labelled `A` and `B`. A caller with no naming of
+ * its own may pass the identity function and get ids.
+ */
+export declare function describeDefinition(definition: EntityDefinition, nameOf: (id: EntityId) => string): string;

package/dist/geometry/entities/index.d.ts

@@ -0,0 +1,61 @@
+import { EntityDefinition, EntityId, EntityKind, EntityRegistry, ResolvedEntity, ResolvedEntityOf, ShapeDescriptor } from '../entityModel.js';
+import { Point } from '../point.js';
+import { MeasuredObject } from '../../measure/geometryAdapter.js';
+export { intersectEntities, parameterOnEntity, pointOnEntity } from './relations.js';
+export declare const entityRegistry: EntityRegistry;
+/**
+ * Every kind the registry declares. Read off the registry rather than written
+ * out again, so a consumer that has to enumerate kinds — a snap that offers
+ * every locus, a toolbar that offers every construction — grows with it.
+ */
+export declare const entityKinds: readonly EntityKind[];
+/**
+ * Every kind but the point: the entities a position can lie *on*.
+ *
+ * A point is a location and the rest are loci, which is the one distinction
+ * that survives generalization — it is why `parameterAt` has no meaning for a
+ * point and why snapping asks these kinds and not that one.
+ */
+export declare const objectEntityKinds: readonly EntityKind[];
+/** Every entity `definition` is built on, in declaration order. */
+export declare function parentsOfDefinition(definition: EntityDefinition): readonly EntityId[];
+/**
+ * Evaluates `definition` against its already-resolved parents, which must be
+ * in the order `parentsOfDefinition()` gave. `null` means "not on screen".
+ *
+ * A caller that could not resolve every parent should not call this at all:
+ * passing a short list would silently slide the parents that did resolve into
+ * the wrong positions.
+ */
+export declare function resolveDefinition<D extends EntityDefinition>(definition: D, parents: readonly ResolvedEntity[]): ResolvedEntityOf<D['kind']> | null;
+/**
+ * The resolved form of `definition` against points that have already been
+ * resolved for the scene it belongs to — `null` when it is not on screen.
+ *
+ * For the consumers that hold a definition and a point map rather than a
+ * context: `hitTest()` and `computeSnap()` are handed a scene assembled by a
+ * renderer, and a preview scene has no context to ask. A caller holding an
+ * `IndexedGeometryContext` asks that instead, because its answers are cached
+ * and these are computed per call.
+ */
+export declare function resolveAgainstPoints(definition: EntityDefinition, points: ReadonlyMap<EntityId, Point>): ResolvedEntity | null;
+/** What a renderer draws. */
+export declare function shapeOfResolved(resolved: ResolvedEntity): ShapeDescriptor;
+/** The two-point reduction the measurement seam accepts, or null. */
+export declare function measuredOfResolved(resolved: ResolvedEntity): MeasuredObject | null;
+/** Distance to the drawn object, in math space. */
+export declare function distanceToResolved(resolved: ResolvedEntity, at: Point): number;
+/** Rank at equal distance, lower wins. */
+export declare function hitPriorityOf(kind: EntityKind): number;
+/** The key deciding whether two definitions are the same construction. */
+export declare function identityKeyOf(definition: EntityDefinition): string;
+/**
+ * One sentence saying what this entity is, for the semantic companion (M1b.3).
+ *
+ * `nameOf` resolves a parent id to the name that surface calls it — the
+ * renderer passes `entityDisplayName()`, so "segment from A to B" names the
+ * two points the canvas has labelled `A` and `B`. A caller with no naming of
+ * its own may pass the identity function and get ids.
+ */
+export declare function describeDefinition(definition: EntityDefinition, nameOf: (id: EntityId) => string): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/geometry/entities/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/geometry/entities/index.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EACV,gBAAgB,EAChB,QAAQ,EACR,UAAU,EAEV,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,eAAe,EAChB,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAKnE,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEjF,eAAO,MAAM,cAAc,EAAE,cAK3B,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,UAAU,EAE5C,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAAS,UAAU,EAElD,CAAA;AAaD,mEAAmE;AACnE,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,gBAAgB,GAAG,SAAS,QAAQ,EAAE,CAErF;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,gBAAgB,EAC1D,UAAU,EAAE,CAAC,EACb,OAAO,EAAE,SAAS,cAAc,EAAE,GACjC,gBAAgB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAIpC;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,gBAAgB,EAC5B,MAAM,EAAE,WAAW,CAAC,QAAQ,EAAE,KAAK,CAAC,GACnC,cAAc,GAAG,IAAI,CAWvB;AAED,6BAA6B;AAC7B,wBAAgB,eAAe,CAAC,QAAQ,EAAE,cAAc,GAAG,eAAe,CAEzE;AAED,qEAAqE;AACrE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,cAAc,GAAG,cAAc,GAAG,IAAI,CAElF;AAED,mDAAmD;AACnD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,cAAc,EAAE,EAAE,EAAE,KAAK,GAAG,MAAM,CAE9E;AAED,0CAA0C;AAC1C,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAEtD;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,UAAU,EAAE,gBAAgB,GAAG,MAAM,CAElE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,gBAAgB,EAC5B,MAAM,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,MAAM,GAC/B,MAAM,CAER"}

package/dist/geometry/entities/line.d.cts

@@ -0,0 +1,43 @@
+import { LineDefinition, ResolvedLine } from '../entityModel.cjs';
+export declare const lineOperations: {
+    kind: "line";
+    parents: (definition: LineDefinition) => readonly [string, string];
+    resolve: (_definition: LineDefinition, [from, to]: readonly import('../entityModel.cjs').ResolvedEntity[]) => {
+        kind: "line";
+        through: [{
+            x: number;
+            y: number;
+        }, {
+            x: number;
+            y: number;
+        }];
+    } | null;
+    toShape: (resolved: ResolvedLine) => {
+        shape: "line";
+        through: readonly [{
+            x: number;
+            y: number;
+        }, {
+            x: number;
+            y: number;
+        }];
+    };
+    toMeasured: (resolved: ResolvedLine) => {
+        type: "line";
+        from: {
+            x: number;
+            y: number;
+        };
+        to: {
+            x: number;
+            y: number;
+        };
+    };
+    distanceTo: (resolved: ResolvedLine, at: {
+        x: number;
+        y: number;
+    }) => number;
+    describe: (definition: LineDefinition, nameOf: (id: import('../entityModel.cjs').EntityId) => string) => string;
+    hitPriority: number;
+    identityKey: (definition: LineDefinition) => string;
+};

package/dist/geometry/entities/line.d.ts

@@ -0,0 +1,44 @@
+import { LineDefinition, ResolvedLine } from '../entityModel.js';
+export declare const lineOperations: {
+    kind: "line";
+    parents: (definition: LineDefinition) => readonly [string, string];
+    resolve: (_definition: LineDefinition, [from, to]: readonly import('../entityModel.js').ResolvedEntity[]) => {
+        kind: "line";
+        through: [{
+            x: number;
+            y: number;
+        }, {
+            x: number;
+            y: number;
+        }];
+    } | null;
+    toShape: (resolved: ResolvedLine) => {
+        shape: "line";
+        through: readonly [{
+            x: number;
+            y: number;
+        }, {
+            x: number;
+            y: number;
+        }];
+    };
+    toMeasured: (resolved: ResolvedLine) => {
+        type: "line";
+        from: {
+            x: number;
+            y: number;
+        };
+        to: {
+            x: number;
+            y: number;
+        };
+    };
+    distanceTo: (resolved: ResolvedLine, at: {
+        x: number;
+        y: number;
+    }) => number;
+    describe: (definition: LineDefinition, nameOf: (id: import('../entityModel.js').EntityId) => string) => string;
+    hitPriority: number;
+    identityKey: (definition: LineDefinition) => string;
+};
+//# sourceMappingURL=line.d.ts.map

package/dist/geometry/entities/line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/geometry/entities/line.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAoB,cAAc,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAEpF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2B+B,CAAA"}

package/dist/geometry/entities/point.d.cts

@@ -0,0 +1,27 @@
+import { EntityId, PointDefinition, ResolvedPoint } from '../entityModel.cjs';
+export declare const pointOperations: {
+    kind: "point";
+    parents: (definition: PointDefinition) => readonly string[];
+    resolve: (definition: PointDefinition, parents: readonly import('../entityModel.cjs').ResolvedEntity[]) => {
+        kind: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    } | null;
+    toShape: (resolved: ResolvedPoint) => {
+        shape: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    };
+    toMeasured: () => null;
+    distanceTo: (resolved: ResolvedPoint, at: {
+        x: number;
+        y: number;
+    }) => number;
+    describe: (definition: PointDefinition, nameOf: (id: EntityId) => string) => string;
+    hitPriority: number;
+    identityKey: (definition: PointDefinition) => string;
+};

package/dist/geometry/entities/point.d.ts

@@ -0,0 +1,28 @@
+import { EntityId, PointDefinition, ResolvedPoint } from '../entityModel.js';
+export declare const pointOperations: {
+    kind: "point";
+    parents: (definition: PointDefinition) => readonly string[];
+    resolve: (definition: PointDefinition, parents: readonly import('../entityModel.js').ResolvedEntity[]) => {
+        kind: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    } | null;
+    toShape: (resolved: ResolvedPoint) => {
+        shape: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    };
+    toMeasured: () => null;
+    distanceTo: (resolved: ResolvedPoint, at: {
+        x: number;
+        y: number;
+    }) => number;
+    describe: (definition: PointDefinition, nameOf: (id: EntityId) => string) => string;
+    hitPriority: number;
+    identityKey: (definition: PointDefinition) => string;
+};
+//# sourceMappingURL=point.d.ts.map

package/dist/geometry/entities/point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/geometry/entities/point.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,QAAQ,EAAoB,eAAe,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAYhG,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;CAsEgC,CAAA"}

package/dist/geometry/entities/relations.d.cts

@@ -0,0 +1,27 @@
+import { ResolvedEntity } from '../entityModel.cjs';
+import { Point } from '../point.cjs';
+/**
+ * Where two resolved entities meet, or null when they do not meet at all,
+ * meet only outside a segment's bounds, or are a pair no intersection is
+ * defined for.
+ *
+ * The lookup erases the pair's concrete operand types at one explicit
+ * boundary, exactly as `getGoalKindHandler()` erases a goal's subtype: the
+ * key is built from the operands' own `kind` fields, so the entry selected is
+ * by construction the one whose signature they satisfy.
+ */
+export declare function intersectEntities(first: ResolvedEntity, second: ResolvedEntity, which?: 0 | 1): Point | null;
+/**
+ * The position at parameter `t` along `host`, or null when the host is not
+ * something a parameter can travel along.
+ */
+export declare function pointOnEntity(host: ResolvedEntity, t: number): Point | null;
+/**
+ * The parameter at which `at` projects onto `host`, in the domain the host
+ * actually occupies — or null when the host cannot be parameterized, or is
+ * degenerate at the scale of the query.
+ *
+ * `pointOnEntity(host, parameterOnEntity(host, at))` is the closest place on
+ * `host` to `at`, which is why the two live side by side.
+ */
+export declare function parameterOnEntity(host: ResolvedEntity, at: Point): number | null;

package/dist/geometry/entities/relations.d.ts

@@ -0,0 +1,28 @@
+import { ResolvedEntity } from '../entityModel.js';
+import { Point } from '../point.js';
+/**
+ * Where two resolved entities meet, or null when they do not meet at all,
+ * meet only outside a segment's bounds, or are a pair no intersection is
+ * defined for.
+ *
+ * The lookup erases the pair's concrete operand types at one explicit
+ * boundary, exactly as `getGoalKindHandler()` erases a goal's subtype: the
+ * key is built from the operands' own `kind` fields, so the entry selected is
+ * by construction the one whose signature they satisfy.
+ */
+export declare function intersectEntities(first: ResolvedEntity, second: ResolvedEntity, which?: 0 | 1): Point | null;
+/**
+ * The position at parameter `t` along `host`, or null when the host is not
+ * something a parameter can travel along.
+ */
+export declare function pointOnEntity(host: ResolvedEntity, t: number): Point | null;
+/**
+ * The parameter at which `at` projects onto `host`, in the domain the host
+ * actually occupies — or null when the host cannot be parameterized, or is
+ * degenerate at the scale of the query.
+ *
+ * `pointOnEntity(host, parameterOnEntity(host, at))` is the closest place on
+ * `host` to `at`, which is why the two live side by side.
+ */
+export declare function parameterOnEntity(host: ResolvedEntity, at: Point): number | null;
+//# sourceMappingURL=relations.d.ts.map

package/dist/geometry/entities/relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../../../src/geometry/entities/relations.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAGV,cAAc,EAIf,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAoFrC;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,cAAc,EACtB,KAAK,GAAE,CAAC,GAAG,CAAK,GACf,KAAK,GAAG,IAAI,CAMd;AAqDD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,cAAc,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI,CAM3E;AAqCD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,EAAE,EAAE,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,CAGhF"}

package/dist/geometry/entities/segment.d.cts

@@ -0,0 +1,45 @@
+import { ResolvedSegment, SegmentDefinition } from '../entityModel.cjs';
+export declare const segmentOperations: {
+    kind: "segment";
+    parents: (definition: SegmentDefinition) => readonly [string, string];
+    resolve: (_definition: SegmentDefinition, [from, to]: readonly import('../entityModel.cjs').ResolvedEntity[]) => {
+        kind: "segment";
+        from: {
+            x: number;
+            y: number;
+        };
+        to: {
+            x: number;
+            y: number;
+        };
+    } | null;
+    toShape: (resolved: ResolvedSegment) => {
+        shape: "segment";
+        from: {
+            x: number;
+            y: number;
+        };
+        to: {
+            x: number;
+            y: number;
+        };
+    };
+    toMeasured: (resolved: ResolvedSegment) => {
+        type: "segment";
+        from: {
+            x: number;
+            y: number;
+        };
+        to: {
+            x: number;
+            y: number;
+        };
+    };
+    distanceTo: (resolved: ResolvedSegment, at: {
+        x: number;
+        y: number;
+    }) => number;
+    describe: (definition: SegmentDefinition, nameOf: (id: import('../entityModel.cjs').EntityId) => string) => string;
+    hitPriority: number;
+    identityKey: (definition: SegmentDefinition) => string;
+};

package/dist/geometry/entities/segment.d.ts

@@ -0,0 +1,46 @@
+import { ResolvedSegment, SegmentDefinition } from '../entityModel.js';
+export declare const segmentOperations: {
+    kind: "segment";
+    parents: (definition: SegmentDefinition) => readonly [string, string];
+    resolve: (_definition: SegmentDefinition, [from, to]: readonly import('../entityModel.js').ResolvedEntity[]) => {
+        kind: "segment";
+        from: {
+            x: number;
+            y: number;
+        };
+        to: {
+            x: number;
+            y: number;
+        };
+    } | null;
+    toShape: (resolved: ResolvedSegment) => {
+        shape: "segment";
+        from: {
+            x: number;
+            y: number;
+        };
+        to: {
+            x: number;
+            y: number;
+        };
+    };
+    toMeasured: (resolved: ResolvedSegment) => {
+        type: "segment";
+        from: {
+            x: number;
+            y: number;
+        };
+        to: {
+            x: number;
+            y: number;
+        };
+    };
+    distanceTo: (resolved: ResolvedSegment, at: {
+        x: number;
+        y: number;
+    }) => number;
+    describe: (definition: SegmentDefinition, nameOf: (id: import('../entityModel.js').EntityId) => string) => string;
+    hitPriority: number;
+    identityKey: (definition: SegmentDefinition) => string;
+};
+//# sourceMappingURL=segment.d.ts.map

package/dist/geometry/entities/segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/geometry/entities/segment.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAoB,eAAe,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAE1F,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BkC,CAAA"}

package/dist/geometry/entityCapabilities.d.cts

@@ -0,0 +1,2 @@
+import { EntityCapabilities, EntityRole } from './entityModel.cjs';
+export declare function capabilitiesOf(role: EntityRole): Readonly<EntityCapabilities>;

package/dist/geometry/entityCapabilities.d.ts

@@ -0,0 +1,3 @@
+import { EntityCapabilities, EntityRole } from './entityModel.js';
+export declare function capabilitiesOf(role: EntityRole): Readonly<EntityCapabilities>;
+//# sourceMappingURL=entityCapabilities.d.ts.map

package/dist/geometry/entityCapabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entityCapabilities.d.ts","sourceRoot":"","sources":["../../src/geometry/entityCapabilities.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAcnE,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,QAAQ,CAAC,kBAAkB,CAAC,CAE7E"}