@chronicle.app/moves-app 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrew Louis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,141 @@
+# @chronicle.app/moves-app
+
+Chronicle plugin for the location storyline from [Moves](<https://en.wikipedia.org/wiki/Moves_(application)>) — the automatic activity tracker ProtoGeo built, Facebook bought in 2014, and shut down in July 2018.
+
+## Installation
+
+```bash
+npm install @chronicle.app/moves-app
+```
+
+## Usage
+
+Point the extractor at your unzipped Moves export — the archive the
+moves-export.com service handed you before the shutdown, which is the only way
+this data ever left the app.
+
+### Basic extraction
+
+```bash
+chronicle extract moves-app --input /path/to/moves_export
+```
+
+### With date filtering
+
+```bash
+chronicle extract moves-app \
+  --input /path/to/moves_export \
+  --since 2015-01-01 \
+  --until 2015-12-31 \
+  --limit 1000
+```
+
+## Configuration
+
+- `--input` (required): Path to the unzipped export
+- `--since`: Extract records that start on or after this date
+- `--until`: Extract records that start on or before this date
+- `--limit`: Maximum number of records to extract (the most recent ones)
+
+## File Format
+
+The export holds the same history at five roll-ups (daily, weekly, monthly,
+yearly, full) and in four cuts (storyline, places, activities, summary), in
+several formats. This plugin reads the JSON **storyline**, which is the
+superset: it inlines each day's places and its activities with their GPS track,
+so nothing has to be joined across files.
+
+```
+json/daily/storyline/storyline_YYYYMMDD.json   one day per file
+json/full/storyline.json                       every day in one array
+```
+
+`--input` accepts the export folder, its `json` folder, the daily storyline
+folder, or a storyline JSON file directly — the extractor resolves it. The daily
+folder wins when both are present, because a windowed or limited run then only
+opens the files it needs.
+
+A day is an ordered list of segments, and a segment is one of:
+
+- `place` — a stay: the place it was at, plus any activity recorded there
+- `move` — movement between two stays, split into legs
+- `off` — tracking was off, but the phone still recorded activity
+
+A `move`/`off` segment splits into legs: walk to the station, take the train,
+walk to the office is one segment of three activities, each with its own type,
+distance, and track. The leg is the unit that carries a single mode of travel,
+so the leg — not the segment — is what becomes a journey. The extractor emits
+one record per stay and one per leg:
+
+- `recordType: "places"` for stays
+- `recordType: "moves"` for legs of movement
+
+A segment that spans midnight is written into both days' files. It is deduped on
+its start time, which is also its identity downstream, so both copies land on one
+record.
+
+## Schema
+
+| Source             | Chronicle                                                                            |
+| ------------------ | ------------------------------------------------------------------------------------ |
+| `place` segment    | `VisitAction` → `object: Venue` or `Place`, `startTime`/`endTime`                    |
+| leg of movement    | `TravelAction` → `Journey` (`travelMode`, `distance`, `path`), `startTime`/`endTime` |
+| `place` dictionary | `Venue`/`Place` (name, coordinates, `sameAs` to Foursquare/Facebook)                 |
+
+The source is `moves-app`, after the service's own domain (`moves-app.com`, and
+`dev.moves-app.com` for the format docs the export's PDF points at). Not bare
+`moves`: a source name is a namespace, and it sits beside `moves` the record
+type. Not `facebook-moves` either, though Facebook bought the company in 2014 —
+these ids were minted by the Moves service throughout, and the same place
+records carry `facebookPlaceId` values that belong to the genuinely separate
+`facebook` id space.
+
+Moves numbered its places but never its segments, so a stay and a leg are keyed
+on the instant they began — a person is in one place, and on one leg of one
+journey, at a time. The start is spelled as a UTC ISO string so it hashes the
+same on every replica, and the type is part of the keyset, so a stay, the leg
+that ended it, and that leg's `Journey` never collide.
+
+A place keys on the Moves place id, which Moves issued and reused on every
+visit. A named one is a `Venue`; an unnamed one (a spot Moves detected but never
+named) is a `Place`. Where Moves matched a place against Foursquare or Facebook
+it kept that service's id, which becomes a `sameAs` edge — so the Moves venue
+collapses onto the same entity as that service's own `Venue`, the way an Arc
+Timeline place does.
+
+A leg's `activity` becomes the journey's `travelMode`, in the words Chronicle
+already uses for those modes (Moves' `underground` is written `metro`, as Arc
+Timeline writes it). Where Moves has no counterpart its own word stands:
+`transport` is Moves saying "motorized, but I could not tell which", and
+narrowing it to a car would be an invention. A leg's GPS `trackPoints` become
+the journey's `path`, a GeoJSON `LineString` with per-point times in
+`properties.coordTimes`.
+
+The export carries no account identity — no name, no handle, no user id — so the
+self is the per-source singleton, merged onto the real person through `@me`.
+
+### Not ingested
+
+- **Steps and calories.** Moves counted both, per leg and per day, and neither
+  has a home in the schema today.
+- **Activity recorded while at a place.** Moves logged the walking done inside a
+  venue as an activity on the `place` segment. It has no track and goes
+  nowhere — it is a step count, which is the point above.
+- **Foursquare category ids.** The export carries the ids, not the names, and a
+  raw id is not a category anyone can read.
+- **A place's `type`** (`home`, `work`, `user`) — Moves' note on where the place
+  came from, which has no schema property.
+- **The other cuts and roll-ups.** `places`, `activities`, and `summary` are
+  projections of the storyline; the weekly, monthly, and yearly folders are the
+  same days re-bucketed.
+
+## Development
+
+```bash
+npm install
+npm run build
+npm test
+```
+
+Tests use a small synthetic export written to a temporary folder, so they never
+read the host's Moves data or any account.

package/dist/activityTypes.d.ts

@@ -0,0 +1,3 @@
+export declare const MOVES_TRAVEL_MODES: Record<string, string>;
+export declare function travelModeName(activity: string | undefined): string | undefined;
+//# sourceMappingURL=activityTypes.d.ts.map

package/dist/activityTypes.js

@@ -0,0 +1,31 @@
+// Moves' activity vocabulary, mapped to the travel-mode names Chronicle already
+// carries for the same modes (the Arc Timeline plugin writes `metro`, so Moves'
+// `underground` is written the same way — one word per mode across sources).
+//
+// Where Moves has no counterpart the source's own word stands: `transport` is
+// Moves saying "motorized, but I could not tell which", and narrowing it to a
+// car would be an invention. `escalator` is Moves' own too.
+//
+// `group` is the coarse bucket Moves rolled an activity up under (walking,
+// running, cycling, transport); it is derivable from the activity, so only the
+// specific one is carried.
+export const MOVES_TRAVEL_MODES = {
+    walking: 'walking',
+    running: 'running',
+    cycling: 'cycling',
+    transport: 'transport',
+    train: 'train',
+    bus: 'bus',
+    tram: 'tram',
+    underground: 'metro',
+    airplane: 'airplane',
+    boat: 'boat',
+    funicular: 'funicular',
+    escalator: 'escalator',
+    snowboarding: 'snowboarding',
+};
+export function travelModeName(activity) {
+    if (!activity)
+        return undefined;
+    return MOVES_TRAVEL_MODES[activity] ?? activity;
+}

package/dist/connectors/MovesExtractor.d.ts

@@ -0,0 +1,36 @@
+import { Extractor, Record } from '@chronicle.app/etl';
+import { z } from 'zod';
+import MovesTransformer from './MovesTransformer.js';
+export declare class MovesExtractor extends Extractor<typeof MovesExtractor> {
+    static source: string;
+    static description: string;
+    static delivery: "export";
+    static strategy: string;
+    static recordTypes: string[];
+    static default: boolean;
+    static defaultTransformer: typeof MovesTransformer;
+    static schema: z.ZodObject<{
+        since: z.ZodOptional<z.ZodDate>;
+        until: z.ZodOptional<z.ZodDate>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    } & {
+        input: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        input: string;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }, {
+        input: string;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }>;
+    extract(): AsyncGenerator<Record>;
+    determineCount(): Promise<number | null>;
+    private selectFrom;
+    private readDays;
+    private resolveInput;
+    private listDayFiles;
+}
+//# sourceMappingURL=MovesExtractor.d.ts.map

package/dist/connectors/MovesExtractor.js

@@ -0,0 +1,194 @@
+import { Extractor, selfAgent } from '@chronicle.app/etl';
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { dayKey, parseMovesTime, shiftDayKey } from '../time.js';
+import MovesTransformer from './MovesTransformer.js';
+// A daily storyline file is named for the local day it covers.
+const DAILY_FILE = /^storyline_(\d{8})\.json$/;
+export class MovesExtractor extends Extractor {
+    static source = 'moves-app';
+    static description = 'Location storyline: places and moves';
+    static delivery = 'export';
+    // The strategy, in Moves' own vocabulary: the archive the moves-export.com
+    // service handed you, which is the only way this data ever left the app.
+    static strategy = 'moves-export';
+    static recordTypes = ['places', 'moves'];
+    static default = true;
+    static defaultTransformer = MovesTransformer;
+    static schema = Extractor.schema.extend({
+        input: z
+            .string()
+            .describe('Path to the unzipped Moves export — the export folder, its json/ folder, the daily storyline folder, or a storyline JSON file'),
+    });
+    async *extract() {
+        const config = this.config;
+        // The export carries no account identity — no name, no handle, no user id.
+        // So the self is the per-source singleton, merged onto the real person
+        // through "@me" like every other source's self.
+        const person = selfAgent({
+            source: 'moves-app',
+        });
+        const selected = [];
+        // A segment that spans midnight is written into both days, so the same
+        // segment is read twice. Its start instant tells the copies apart — the
+        // instant, not the string Moves wrote it as, which is the same identity the
+        // transformer keys on and holds even if the two copies carry different
+        // offsets.
+        const seen = new Set();
+        for await (const day of this.readDays(config.input)) {
+            for (const segment of [...(day.segments ?? [])].reverse()) {
+                for (const item of this.selectFrom(segment)) {
+                    const start = parseMovesTime(item.data.startTime);
+                    if (!start)
+                        continue;
+                    const marker = `${item.recordType}:${start.toISOString()}`;
+                    if (seen.has(marker))
+                        continue;
+                    if (config.since && start < config.since)
+                        continue;
+                    if (config.until && start > config.until)
+                        continue;
+                    seen.add(marker);
+                    selected.push(item);
+                    if (this.shouldStopExtracting(selected.length))
+                        break;
+                }
+                if (this.shouldStopExtracting(selected.length))
+                    break;
+            }
+            if (this.shouldStopExtracting(selected.length))
+                break;
+        }
+        this.logInitStep(`Emitting ${selected.length} records ` +
+            `(${selected.filter(s => s.recordType === 'places').length} places, ` +
+            `${selected.filter(s => s.recordType === 'moves').length} moves)`);
+        for (const { data, recordType } of selected) {
+            yield this.createRecord(data, { recordType, person });
+        }
+    }
+    async determineCount() {
+        const config = this.config;
+        try {
+            const seen = new Set();
+            for await (const day of this.readDays(config.input)) {
+                for (const segment of day.segments ?? []) {
+                    for (const item of this.selectFrom(segment)) {
+                        const start = parseMovesTime(item.data.startTime);
+                        if (!start)
+                            continue;
+                        if (config.since && start < config.since)
+                            continue;
+                        if (config.until && start > config.until)
+                            continue;
+                        seen.add(`${item.recordType}:${start.toISOString()}`);
+                    }
+                }
+            }
+            const limit = this.getEffectiveLimit();
+            return limit === null ? seen.size : Math.min(seen.size, limit);
+        }
+        catch {
+            return null;
+        }
+    }
+    // The records a segment yields. A stay is one record. Movement splits into
+    // its legs — each carries a single mode of travel, its own distance, and its
+    // own track, which is what a Journey holds. A leg recorded while at a place
+    // (walking around inside a venue) went nowhere, so it yields nothing.
+    selectFrom(segment) {
+        if (segment.type === 'place') {
+            return segment.place ? [{ data: segment, recordType: 'places' }] : [];
+        }
+        return (segment.activities ?? []).map(activity => ({
+            data: activity,
+            recordType: 'moves',
+        }));
+    }
+    // The storyline days, newest first, so `--limit N` yields the N most recent
+    // records. A day file is read and released one at a time; the single full
+    // file is read whole, because it is one JSON array.
+    async *readDays(input) {
+        const config = this.config;
+        const source = await this.resolveInput(input);
+        // The since/until window, widened by a day at each edge: a file is named
+        // for the local day it covers and the window is UTC, so a file just outside
+        // the window can still hold a segment inside it. The per-segment check is
+        // what decides; this only skips files that cannot contribute.
+        const sinceKey = config.since ? shiftDayKey(dayKey(config.since), -1) : undefined;
+        const untilKey = config.until ? shiftDayKey(dayKey(config.until), 1) : undefined;
+        if (source.kind === 'file') {
+            const days = JSON.parse(await readFile(source.path, 'utf-8'));
+            for (const day of [...days].reverse()) {
+                if (sinceKey && day.date < sinceKey)
+                    break;
+                if (untilKey && day.date > untilKey)
+                    continue;
+                yield day;
+            }
+            return;
+        }
+        for (const { path, key } of source.files) {
+            // Day keys sort chronologically, so every remaining file is older still.
+            if (sinceKey && key < sinceKey)
+                break;
+            if (untilKey && key > untilKey)
+                continue;
+            const days = JSON.parse(await readFile(path, 'utf-8'));
+            for (const day of [...days].reverse())
+                yield day;
+        }
+    }
+    // Resolve the input to the storyline itself. The input may be the folder of
+    // daily files, a single storyline JSON file, or a parent that is easier to
+    // point at — the export root or its json/ folder. The daily folder wins when
+    // both are present: it holds the same data, and a limited or windowed run
+    // only opens the files it needs.
+    async resolveInput(input) {
+        const dailyDirs = [
+            input,
+            join(input, 'daily', 'storyline'),
+            join(input, 'json', 'daily', 'storyline'),
+        ];
+        for (const dir of dailyDirs) {
+            const files = await this.listDayFiles(dir);
+            if (files.length > 0)
+                return { kind: 'daily', files };
+        }
+        const fullFiles = [
+            input,
+            join(input, 'full', 'storyline.json'),
+            join(input, 'json', 'full', 'storyline.json'),
+        ];
+        for (const path of fullFiles) {
+            if (!path.endsWith('.json'))
+                continue;
+            try {
+                if ((await stat(path)).isFile())
+                    return { kind: 'file', path };
+            }
+            catch {
+                continue; // Not there — try the next candidate.
+            }
+        }
+        throw new Error(`No Moves storyline found under ${input} — expected a folder of ` +
+            `storyline_YYYYMMDD.json files or a storyline.json, in there, in ` +
+            `daily/storyline/, in full/, or under json/`);
+    }
+    // The daily storyline files in a folder, newest first. An empty list means
+    // this folder is not the one.
+    async listDayFiles(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir);
+        }
+        catch {
+            return []; // Not a directory — the caller tries the next candidate.
+        }
+        return entries
+            .map(name => DAILY_FILE.exec(name))
+            .filter((match) => match !== null)
+            .map(match => ({ path: join(dir, match[0]), key: match[1] }))
+            .sort((a, b) => b.key.localeCompare(a.key));
+    }
+}

package/dist/connectors/MovesTransformer.d.ts

@@ -0,0 +1,12 @@
+import { ChronicleTransformer, Record } from '@chronicle.app/etl';
+import { ActionAndChildren } from '@chronicle.app/schema';
+export default class MovesTransformer extends ChronicleTransformer {
+    transform(record: Record): Promise<ActionAndChildren[]>;
+    private buildVisit;
+    private buildTravel;
+    private spanKey;
+    private buildPlace;
+    private buildLocation;
+    private buildPlaceSameAs;
+}
+//# sourceMappingURL=MovesTransformer.d.ts.map

package/dist/connectors/MovesTransformer.js

@@ -0,0 +1,117 @@
+import { ChronicleTransformer } from '@chronicle.app/etl';
+import { travelModeName } from '../activityTypes.js';
+import { movesTimeToIso } from '../time.js';
+import { buildTrackFeature } from '../track.js';
+export default class MovesTransformer extends ChronicleTransformer {
+    async transform(record) {
+        const context = record.context;
+        if (context.recordType === 'places') {
+            return this.buildVisit(record.data, context.person);
+        }
+        if (context.recordType === 'moves') {
+            return this.buildTravel(record.data, context.person);
+        }
+        return [];
+    }
+    buildVisit(segment, person) {
+        const { place } = segment;
+        const startTime = movesTimeToIso(segment.startTime);
+        const endTime = movesTimeToIso(segment.endTime);
+        if (!place || !startTime)
+            return [];
+        const action = {
+            '@type': 'VisitAction',
+            '@key': this.spanKey(startTime),
+            source: 'moves-app',
+            agent: person,
+            object: this.buildPlace(place),
+            startTime,
+            ...(endTime && { endTime }),
+        };
+        return [action];
+    }
+    buildTravel(activity, person) {
+        const startTime = movesTimeToIso(activity.startTime);
+        const endTime = movesTimeToIso(activity.endTime);
+        if (!startTime)
+            return [];
+        // The action stays sparse; the detail lives on the Journey it produces.
+        const mode = travelModeName(activity.activity);
+        const path = buildTrackFeature(activity.trackPoints);
+        const journey = {
+            '@type': 'Journey',
+            '@key': this.spanKey(startTime),
+            source: 'moves-app',
+            ...(activity.distance !== undefined && { distance: activity.distance }),
+            ...(mode && { travelMode: mode }),
+            ...(path && { path }),
+        };
+        const action = {
+            '@type': 'TravelAction',
+            '@key': this.spanKey(startTime),
+            source: 'moves-app',
+            agent: person,
+            result: journey,
+            startTime,
+            ...(endTime && { endTime }),
+        };
+        return [action];
+    }
+    // A segment carries no id in the export — Moves numbered its places, never
+    // its segments. What identifies one is when it began: a person is in one
+    // place, and on one leg of one journey, at a time. So the start instant is
+    // the natural key, spelled as a UTC ISO string so it hashes the same on every
+    // replica. The type is part of the keyset, so a stay, the leg that ended it,
+    // and that leg's Journey never collide.
+    spanKey(startTime) {
+        return ['@type', 'source', { key: 'startTime', value: startTime }];
+    }
+    // A named place is a point of interest → a Venue; an unnamed one is a spot
+    // Moves detected but never named → a Place. Either way it keys on the Moves
+    // place id, which is the id Moves issued and reused on every visit, and either
+    // way it carries whatever identity edges the place has: the name decides the
+    // type, never whether a foreign id is reported.
+    buildPlace(place) {
+        const sameAs = this.buildPlaceSameAs(place);
+        const common = {
+            '@key': ['@type', 'source', 'sourceId'],
+            source: 'moves-app',
+            sourceId: String(place.id),
+            // The place's coordinates are its own Location value — a keyless
+            // (content-interned) geo node, not entity properties on the place.
+            location: this.buildLocation(place),
+            ...(sameAs.length > 0 && { sameAs }),
+        };
+        return place.name
+            ? { '@type': 'Venue', ...common, name: place.name }
+            : { '@type': 'Place', ...common };
+    }
+    buildLocation(place) {
+        return {
+            '@type': 'Location',
+            latitude: place.location.lat,
+            longitude: place.location.lon,
+        };
+    }
+    // Moves matched some places against Foursquare and Facebook and kept those
+    // services' ids. Emit a sameAs edge per id so the Moves place collapses into
+    // the same entity as that service's own Venue (which keys identically on
+    // [@type, source, sourceId]). The id is a real handle from the export — never
+    // synthesized — and each edge carries the title when there is one, so a
+    // yet-unseen foreign venue still has a name when this edge is what mints it.
+    buildPlaceSameAs(place) {
+        const edges = [
+            { source: 'foursquare', sourceId: place.foursquareId },
+            { source: 'facebook', sourceId: place.facebookPlaceId },
+        ];
+        return edges
+            .filter((edge) => Boolean(edge.sourceId))
+            .map(edge => ({
+            '@type': 'Venue',
+            '@key': ['@type', 'source', 'sourceId'],
+            source: edge.source,
+            sourceId: edge.sourceId,
+            ...(place.name && { name: place.name }),
+        }));
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { MovesExtractor } from './connectors/MovesExtractor.js';
+export { default as MovesTransformer } from './connectors/MovesTransformer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,2 @@
+export { MovesExtractor } from './connectors/MovesExtractor.js';
+export { default as MovesTransformer } from './connectors/MovesTransformer.js';

package/dist/time.d.ts

@@ -0,0 +1,6 @@
+import { MovesTime } from './types.js';
+export declare function parseMovesTime(value: MovesTime): Date | undefined;
+export declare function movesTimeToIso(value: MovesTime): string | undefined;
+export declare function dayKey(date: Date): string;
+export declare function shiftDayKey(key: string, days: number): string;
+//# sourceMappingURL=time.d.ts.map

package/dist/time.js

@@ -0,0 +1,35 @@
+// Moves writes times in the ISO 8601 *basic* format — "20140510T134349-0300"
+// (local wall clock plus the offset it was read at) or "20141021T042519Z".
+// JavaScript's Date only parses the extended format, so the separators go back
+// in before parsing. The offset is part of the string, so the instant is exact
+// and does not depend on where the import runs.
+const BASIC_TIME = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})(Z|[+-]\d{4})$/;
+export function parseMovesTime(value) {
+    const match = BASIC_TIME.exec(value);
+    if (!match)
+        return undefined;
+    const [, year, month, day, hour, minute, second, zone] = match;
+    const offset = zone === 'Z' ? 'Z' : `${zone.slice(0, 3)}:${zone.slice(3)}`;
+    const date = new Date(`${year}-${month}-${day}T${hour}:${minute}:${second}${offset}`);
+    return Number.isNaN(date.getTime()) ? undefined : date;
+}
+// The same instant as an ISO string, which is what the payload carries and what
+// the dedupe keysets hash. A segment has no id in the export, so its start is
+// its identity — the value has to be a plain string, spelled the same way on
+// every run and every replica.
+export function movesTimeToIso(value) {
+    return parseMovesTime(value)?.toISOString();
+}
+// The "YYYYMMDD" day key a daily storyline file is named for.
+export function dayKey(date) {
+    return date.toISOString().slice(0, 10).replaceAll('-', '');
+}
+// A day key shifted by whole days, used to widen a since/until window before it
+// is applied to file names. A file is named for the *local* day it covers, and
+// the window is given as UTC, so the two disagree by up to a day at the edges.
+// The exact filter is the per-segment start-time check; this one only decides
+// which files are worth opening, so it errs one day wide on each side.
+export function shiftDayKey(key, days) {
+    const ms = Date.UTC(Number(key.slice(0, 4)), Number(key.slice(4, 6)) - 1, Number(key.slice(6, 8)));
+    return dayKey(new Date(ms + days * 86_400_000));
+}

package/dist/track.d.ts

@@ -0,0 +1,3 @@
+import { MovesTrackPoint } from './types.js';
+export declare function buildTrackFeature(points: MovesTrackPoint[] | undefined): string | undefined;
+//# sourceMappingURL=track.d.ts.map

package/dist/track.js

@@ -0,0 +1,33 @@
+import { movesTimeToIso } from './time.js';
+// A leg's GPS trail as a GeoJSON `Feature` (LineString) with per-point time
+// carried in `properties.coordTimes`, the Mapbox convention — so it round-trips
+// to GPX and renders directly. Stored verbatim as the Journey's `path` (a JSON
+// string in a Text property), the same encoding the Arc Timeline plugin writes.
+//
+// Moves records only position and time per fix; there is no speed or course to
+// carry, so those arrays are absent rather than filled with nulls.
+//
+// Returns undefined when there are fewer than two fixes — a line needs two
+// points, and Moves leaves the track empty on legs it inferred without GPS.
+export function buildTrackFeature(points) {
+    if (!points || points.length < 2)
+        return undefined;
+    const coordinates = [];
+    const coordTimes = [];
+    for (const point of points) {
+        if (typeof point.lat !== 'number' || typeof point.lon !== 'number')
+            continue;
+        const time = movesTimeToIso(point.time);
+        if (!time)
+            continue;
+        coordinates.push([point.lon, point.lat]);
+        coordTimes.push(time);
+    }
+    if (coordinates.length < 2)
+        return undefined;
+    return JSON.stringify({
+        type: 'Feature',
+        geometry: { type: 'LineString', coordinates },
+        properties: { coordTimes },
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,50 @@
+import { AgentAndChildren } from '@chronicle.app/schema';
+export type MovesTime = string;
+export interface MovesLocation {
+    lat: number;
+    lon: number;
+}
+export interface MovesPlace {
+    id: number;
+    name?: string;
+    type: 'home' | 'work' | 'user' | 'foursquare' | 'facebook' | 'unknown';
+    location: MovesLocation;
+    foursquareId?: string;
+    foursquareCategoryIds?: string[];
+    facebookPlaceId?: string;
+}
+export interface MovesTrackPoint {
+    lat: number;
+    lon: number;
+    time: MovesTime;
+}
+export interface MovesActivity {
+    activity: string;
+    group?: string;
+    manual?: boolean;
+    startTime: MovesTime;
+    endTime: MovesTime;
+    duration?: number;
+    distance?: number;
+    steps?: number;
+    calories?: number;
+    trackPoints?: MovesTrackPoint[];
+}
+export interface MovesSegment {
+    type: 'place' | 'move' | 'off';
+    startTime: MovesTime;
+    endTime: MovesTime;
+    place?: MovesPlace;
+    activities?: MovesActivity[];
+    lastUpdate?: MovesTime;
+}
+export interface MovesDay {
+    date: string;
+    segments?: MovesSegment[];
+    lastUpdate?: MovesTime;
+}
+export interface MovesRecordContext {
+    recordType: 'places' | 'moves';
+    person: AgentAndChildren;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@chronicle.app/moves-app",
+  "version": "0.3.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc -b tsconfig.lib.json",
+    "typecheck": "tsc -p tsconfig.json",
+    "lint": "eslint src --ext .ts,.js",
+    "test": "node --test src/*.test.js"
+  },
+  "keywords": [
+    "chronicle",
+    "moves-app"
+  ],
+  "author": "Andrew Louis",
+  "license": "MIT",
+  "type": "module",
+  "description": "Chronicle plugin for the location storyline from a Moves data export",
+  "devDependencies": {
+    "@chronicle.app/etl": "0.3.0",
+    "@chronicle.app/schema": "0.3.0",
+    "@chronicle.app/tsconfig": "0.3.0",
+    "@types/node": "^22.10.1",
+    "typescript": "^5.7.2"
+  },
+  "homepage": "https://chronicle.app",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chronicle-app/chronicle.git",
+    "directory": "plugins/moves-app"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "zod": "^3.24.1"
+  },
+  "peerDependencies": {
+    "@chronicle.app/etl": ">=0.1.0 <1.0.0",
+    "@chronicle.app/schema": ">=0.1.0 <1.0.0"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "chronicle": {
+    "plugin": true,
+    "sources": {
+      "moves-app": {
+        "strategies": {
+          "moves-export": {
+            "delivery": "export",
+            "recordTypes": [
+              "places",
+              "moves"
+            ],
+            "default": true
+          }
+        }
+      }
+    }
+  }
+}