@chronicle.app/timing-app 0.3.0

package/dist/connectors/TimingAppTransformer.js

@@ -0,0 +1,331 @@
+import { ChronicleTransformer, SystemInfo } from '@chronicle.app/etl';
+import path from 'node:path';
+const SOURCE = 'timing-app';
+export default class TimingAppTransformer extends ChronicleTransformer {
+    static source = SOURCE;
+    meAgent;
+    async transform(record) {
+        switch (record.extraction.recordType) {
+            case 'app-activities':
+                return [this.buildAppActivity(record)];
+            case 'time-entries':
+                return [this.buildTimeEntry(record)];
+            default:
+                return [];
+        }
+    }
+    /**
+     * The account owner, tagged `@me`. Timing has no account of its own (and it is
+     * not an iCloud identity), so we don't assume a name — the node is just the
+     * `@me` tag sourced to Timing, keyed on `['@type','source']`. The `@me` token
+     * merges it with the subject's named identities from other sources.
+     */
+    me() {
+        if (!this.meAgent) {
+            this.meAgent = {
+                '@type': 'Agent',
+                '@key': ['@type', 'source'],
+                source: SOURCE,
+                sameAs: ['@me'],
+            };
+        }
+        return this.meAgent;
+    }
+    // --- Projects -------------------------------------------------------------
+    /**
+     * A Project node with its ancestry nested via isPartOf. `chain` is leaf-first
+     * ([self, parent, ...]); returns the leaf node, or null when unattributed.
+     *
+     * Each node asserts `isPartOf` as the complete parent set as of this read, so
+     * a project reparented (or promoted to root) in Timing closes its old parent
+     * edge instead of accumulating both.
+     */
+    buildProjectChain(chain) {
+        let child = null;
+        for (let i = chain.length - 1; i >= 0; i--) {
+            const node = {
+                '@type': 'Project',
+                '@key': ['@type', 'source', 'sourceId'],
+                source: SOURCE,
+                sourceId: chain[i].id,
+                name: chain[i].title,
+                '@asserts': ['isPartOf'],
+            };
+            if (child)
+                node.isPartOf = [child];
+            child = node;
+        }
+        return child;
+    }
+    // --- App activity ---------------------------------------------------------
+    buildAppActivity(record) {
+        const ctx = record.context;
+        const session = {
+            '@type': 'DeviceSession',
+            '@key': ['@type', 'source', 'sourceId'],
+            source: SOURCE,
+            sourceId: ctx.id,
+        };
+        const project = this.buildProjectChain(ctx.projectChain);
+        if (project)
+            session.isPartOf = [project];
+        // The logical machine (a name-keyed :Realm) scopes file paths and unifies
+        // with the same host seen from other sources; the physical device (keyed on
+        // its hardware, distinct per machine) is the instrument and links to the
+        // realm via inRealm.
+        const realm = this.buildRealm(ctx.device);
+        const device = this.buildDevice(ctx.device, realm);
+        const resource = this.buildResource(ctx.pathString, realm);
+        if (resource?.['@type'] === 'Directory') {
+            // A directory is where the activity happened (a terminal's CWD, a Finder
+            // folder) — the session's location, not the resource in focus.
+            session.workingDirectory = resource;
+        }
+        else if (resource) {
+            session.subject = [resource];
+        }
+        // The window title describes the session (what this window showed during the
+        // block), not the resource — a subject folds across every session that
+        // touches it, so it keeps its own stable name (the path basename) while the
+        // title, which changes block to block ("sleep 4", a path abbreviation, a page
+        // title), names the session. Skip it when it only repeats the subject's name
+        // (an editor titling itself with the file it already points at).
+        const title = ctx.windowTitle ? stripWindowTitle(ctx.windowTitle, ctx.app.title) : null;
+        if (title && title !== resource?.name) {
+            session.name = title;
+        }
+        const action = {
+            '@type': 'ExecuteAction',
+            '@key': ['@type', 'source', 'sourceId'],
+            source: SOURCE,
+            sourceId: ctx.id,
+            startTime: secondsToISO(ctx.startDate),
+            endTime: secondsToISO(ctx.endDate),
+            agent: this.me(),
+            result: session,
+        };
+        const app = this.buildApplication(ctx.app);
+        if (app)
+            action.object = app;
+        if (device)
+            action.instrument = device;
+        return action;
+    }
+    /** The on-screen resource: a URL-keyed web page, or a realm-scoped filesystem entry. */
+    buildResource(pathString, realm) {
+        if (!pathString)
+            return null;
+        // A web page: globally unique, content-addressed by URL. Its title is the
+        // session's (set by the caller) — here the URL is the whole identity.
+        if (/^https?:\/\//i.test(pathString)) {
+            return {
+                '@type': 'Entity',
+                '@key': ['url'],
+                url: pathString,
+            };
+        }
+        // A filesystem entry. Timing stores these as file:// URIs (or, rarely, bare
+        // paths). A path is not globally unique, so scope it by the machine whose
+        // filesystem it lives on, via `inRealm` — so the same path folds with that
+        // machine seen from other sources (e.g. shell) and survives a hardware
+        // migration, while paths on different machines stay distinct. `@type` is kept
+        // out of the key: a path is one entry, and neither the dir-vs-file signal (a
+        // trailing slash) nor a later, more specific media type may fragment identity.
+        //
+        // A trailing slash is Timing's directory marker (a terminal's CWD, a Finder
+        // folder) → a :Directory. Anything else IS the media object living at that
+        // path, leaf-typed as far as the extension can tell — a path-only source
+        // never sees bytes, so unknown extensions stay a plain :MediaObject and a
+        // byte-reader may refine later (specificity wins at fold time). The name is
+        // the path's basename either way.
+        const filePath = toFilePath(pathString);
+        if (filePath && realm) {
+            const isDir = filePath.endsWith('/');
+            const handle = isDir ? filePath.replace(/\/+$/, '') : filePath;
+            if (!handle)
+                return null;
+            return {
+                '@type': isDir ? 'Directory' : mediaTypeForPath(handle),
+                '@key': ['source', 'handle', 'inRealm.handle'],
+                source: 'filesystem',
+                handle,
+                name: path.basename(handle) || handle,
+                inRealm: realm,
+            };
+        }
+        return null;
+    }
+    /**
+     * The logical machine as a name-keyed `:Realm` — a file's `inRealm` scope and
+     * the device's `inRealm`. Keyed on the normalized name (Timing's device name →
+     * `pat-mbp`), so it folds with the same machine seen by the shell plugin, unifies
+     * across sources, and survives the hardware migrating.
+     */
+    buildRealm(device) {
+        if (!device?.name)
+            return null;
+        const handle = SystemInfo.normalizeMachineName(device.name);
+        if (!handle)
+            return null;
+        return {
+            '@type': 'Realm',
+            '@key': ['@type', 'source', 'handle'],
+            source: 'hostname',
+            handle,
+        };
+    }
+    /**
+     * The physical device — the action's `instrument`. Keyed on Timing's stable
+     * device id (with the hardware MAC linked via `sameAs`), so distinct hardware
+     * stays distinct: two MAC addresses are two devices, never merged. `inRealm`
+     * links it to the logical machine (`realm`) it runs on.
+     */
+    buildDevice(device, realm) {
+        if (!device)
+            return null;
+        const node = {
+            '@type': 'Device',
+            '@key': ['@type', 'source', 'sourceId'],
+            source: SOURCE,
+            sourceId: device.globalId,
+            name: device.name,
+        };
+        // Kind is open-ended data on :category (not a subclass); make/model on :model.
+        const category = deviceCategory(device.model);
+        if (category)
+            node.category = [category];
+        if (device.model)
+            node.model = device.model;
+        if (device.mac) {
+            node.sameAs = [
+                {
+                    '@type': 'Device',
+                    '@key': ['@type', 'source', 'handle'],
+                    source: 'mac-address',
+                    handle: device.mac,
+                },
+            ];
+        }
+        if (realm)
+            node.inRealm = realm;
+        return node;
+    }
+    buildApplication(app) {
+        if (app.bundleIdentifier) {
+            return {
+                '@type': 'SoftwareApplication',
+                '@key': ['@type', 'source', 'handle'],
+                source: 'apple-bundle-id',
+                handle: app.bundleIdentifier,
+                ...(app.title ? { name: app.title } : {}),
+            };
+        }
+        const handle = app.executable || app.title;
+        if (!handle)
+            return null; // degenerate app row (no bundle/executable/title) — can't key
+        return {
+            '@type': 'SoftwareApplication',
+            '@key': ['@type', 'source', 'handle'],
+            source: SOURCE,
+            handle,
+            ...(app.title ? { name: app.title } : {}),
+        };
+    }
+    // --- Time entries ---------------------------------------------------------
+    /**
+     * A manually-logged time entry. It's real lived activity (not a plan), so it's
+     * an `ExperienceAction` carrying the real occurrence, with the produced `Session`
+     * as its `result` — symmetric with app usage (`ExecuteAction` → `DeviceSession`).
+     */
+    buildTimeEntry(record) {
+        const ctx = record.context;
+        const session = {
+            '@type': 'Session',
+            '@key': ['@type', 'source', 'sourceId'],
+            source: SOURCE,
+            sourceId: ctx.id,
+        };
+        if (ctx.title)
+            session.name = ctx.title;
+        if (ctx.notes)
+            session.description = ctx.notes;
+        const project = this.buildProjectChain(ctx.projectChain);
+        if (project)
+            session.isPartOf = [project];
+        const action = {
+            '@type': 'ExperienceAction',
+            '@key': ['@type', 'source', 'sourceId'],
+            source: SOURCE,
+            sourceId: ctx.id,
+            startTime: secondsToISO(ctx.startDate),
+            endTime: secondsToISO(ctx.endDate),
+            agent: this.me(),
+            result: session,
+        };
+        return action;
+    }
+}
+function secondsToISO(seconds) {
+    return new Date(seconds * 1000).toISOString();
+}
+/** The device kind (open-ended :category data), inferred from Timing's model code. */
+function deviceCategory(model) {
+    if (!model)
+        return null;
+    if (/^Mac/i.test(model))
+        return 'computer';
+    if (/^iPhone/i.test(model))
+        return 'phone';
+    if (/^iPad/i.test(model))
+        return 'tablet';
+    return null;
+}
+/** Normalize a Timing Path value to an absolute filesystem path, or null if it isn't one. */
+function toFilePath(value) {
+    let p = value;
+    if (/^file:\/\//i.test(p)) {
+        p = p.replace(/^file:\/\//i, '');
+        try {
+            p = decodeURI(p);
+        }
+        catch {
+            // keep the raw (still-encoded) path rather than dropping the file
+        }
+    }
+    else if (!p.startsWith('/')) {
+        return null;
+    }
+    const trimmed = p.trim();
+    return trimmed && trimmed !== '/' ? trimmed : null;
+}
+/**
+ * The most specific :MediaObject leaf a path's extension supports. The
+ * path-keyed entity IS the media object living there, typed as well as a
+ * path-only observer can tell; anything unrecognized (code, data, no extension)
+ * stays a plain MediaObject for a byte-reader to refine later.
+ */
+const MEDIA_TYPE_BY_EXTENSION = {
+    ...leafType('ImageObject', 'png jpg jpeg gif webp heic heif svg tiff tif bmp ico'),
+    ...leafType('AudioObject', 'mp3 wav aac flac m4a ogg aiff wma'),
+    ...leafType('VideoObject', 'mp4 mov avi mkv webm m4v wmv flv'),
+    ...leafType('DocumentObject', 'pdf doc docx txt md markdown rtf pages key ppt pptx xls xlsx csv numbers epub odt tex'),
+};
+function leafType(type, extensions) {
+    return Object.fromEntries(extensions.split(' ').map(ext => [ext, type]));
+}
+function mediaTypeForPath(handle) {
+    const ext = path.extname(handle).slice(1).toLowerCase();
+    return MEDIA_TYPE_BY_EXTENSION[ext] ?? 'MediaObject';
+}
+/** Drop a trailing " - <app>" / " — <app>" suffix that just repeats the app name. */
+function stripWindowTitle(title, appTitle) {
+    const trimmed = title.trim();
+    if (appTitle) {
+        for (const sep of [' - ', ' — ', ' – ']) {
+            const suffix = `${sep}${appTitle}`;
+            if (trimmed.endsWith(suffix))
+                return trimmed.slice(0, -suffix.length).trim();
+        }
+    }
+    return trimmed;
+}

package/dist/connectors/TimingCallExtractor.d.ts

@@ -0,0 +1,25 @@
+import { Record } from '@chronicle.app/etl';
+import { SqliteExtractor } from '@chronicle.app/etl-sqlite';
+import TimingCallTransformer from './TimingCallTransformer.js';
+/**
+ * Timing.app's relay of Apple Call History — the historical supplement for the
+ * long tail Apple has pruned. Grouped under the `timing-app` source (it reads
+ * Timing's DB → `chronicle extract timing-app --type calls`), but its
+ * *records* emit `source: apple-call-history` keyed on the shared call UUID
+ * (`Event.origin_id`), so they fold with the Apple Call History plugin's
+ * calls. Direction is lost here, and named contacts carry no number (only the
+ * name).
+ */
+export declare class TimingCallExtractor extends SqliteExtractor<typeof TimingCallExtractor> {
+    static source: string;
+    static description: string;
+    static delivery: "local";
+    static strategy: string;
+    static recordTypes: string[];
+    static default: boolean;
+    static defaultTransformer: typeof TimingCallTransformer;
+    static temporality: "event";
+    static schema: any;
+    extract(): AsyncGenerator<Record>;
+}
+//# sourceMappingURL=TimingCallExtractor.d.ts.map

package/dist/connectors/TimingCallExtractor.js

@@ -0,0 +1,78 @@
+import { normalizePhoneNumber } from '@chronicle.app/etl';
+import { SqliteExtractor, iterateRows } from '@chronicle.app/etl-sqlite';
+import { z } from 'zod';
+import TimingCallTransformer from './TimingCallTransformer.js';
+const DEFAULT_DB = `${process.env.HOME}/Library/Application Support/info.eurocomp.Timing2/SQLite.db`;
+/**
+ * Timing.app's relay of Apple Call History — the historical supplement for the
+ * long tail Apple has pruned. Grouped under the `timing-app` source (it reads
+ * Timing's DB → `chronicle extract timing-app --type calls`), but its
+ * *records* emit `source: apple-call-history` keyed on the shared call UUID
+ * (`Event.origin_id`), so they fold with the Apple Call History plugin's
+ * calls. Direction is lost here, and named contacts carry no number (only the
+ * name).
+ */
+export class TimingCallExtractor extends SqliteExtractor {
+    static source = 'timing-app';
+    static description = 'Phone and FaceTime calls (historical supplement)';
+    static delivery = 'local';
+    static strategy = 'app-db';
+    static recordTypes = ['calls'];
+    static default = false;
+    static defaultTransformer = TimingCallTransformer;
+    static temporality = 'event';
+    static schema = SqliteExtractor.schema.omit({ input: true }).extend({
+        input: z.string().describe("Path to Timing.app's SQLite.db").default(DEFAULT_DB),
+    });
+    async *extract() {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        const conditions = [
+            "i.type = 'com.apple.CallHistory'",
+            'e.deleted_at IS NULL',
+            'e.origin_id IS NOT NULL',
+        ];
+        const params = [];
+        if (this.config.since) {
+            conditions.push('e.start_date > ?');
+            params.push(this.config.since.getTime() / 1000);
+        }
+        if (this.config.until) {
+            conditions.push('e.start_date < ?');
+            params.push(this.config.until.getTime() / 1000);
+        }
+        const limit = this.getEffectiveLimit();
+        let sql = `
+      SELECT e.origin_id AS uuid, e.start_date AS startSec, e.end_date AS endSec,
+             es.title AS contactTitle, es.event_source_type AS sourceType
+      FROM Event e
+      JOIN Integration i ON e.integration_id = i.id
+      LEFT JOIN EventSource es ON e.event_source_id = es.id
+      WHERE ${conditions.join(' AND ')}
+      ORDER BY e.start_date DESC`;
+        if (limit !== null) {
+            sql += ` LIMIT ?`;
+            params.push(limit);
+        }
+        for (const row of iterateRows(this.db.prepare(sql), ...params)) {
+            // The title is either a real handle (unnamed contact) or a display name.
+            const title = row.contactTitle || null;
+            let handle = null;
+            let contactName = null;
+            if (title) {
+                if (title.includes('@') || normalizePhoneNumber(title))
+                    handle = title;
+                else
+                    contactName = title;
+            }
+            yield this.createRecord({}, {
+                recordType: 'calls',
+                uuid: row.uuid,
+                startSec: row.startSec,
+                endSec: row.endSec ?? null,
+                handle,
+                contactName,
+            });
+        }
+    }
+}

package/dist/connectors/TimingCallTransformer.d.ts

@@ -0,0 +1,22 @@
+import { ChronicleTransformer, Record } from '@chronicle.app/etl';
+import { ActionAndChildren } from '@chronicle.app/schema';
+/**
+ * Timing's relay of Apple Call History — the historical supplement for the long
+ * tail Apple has pruned (82% of Timing calls predate Apple's retention). Same
+ * shape as an Apple call. The party:
+ *   - unnamed contact (a raw handle)  → an `apple-call-history` party (folds via handle),
+ *   - named contact, resolvable       → the `apple-contacts` party,
+ *   - named contact, unresolvable     → no party; Timing's label rides on a
+ *       `sameAs`'d `timing-app` CallSession (a sourced fact, not a fabricated
+ *       Person, not the canonical session's own name).
+ *
+ * Caveat: Timing records no direction, so a resolved party goes on `recipient`
+ * (the best available slot). For a call that ALSO exists in Apple, Apple is
+ * authoritative for direction; this adds coverage for the pruned tail.
+ */
+export default class TimingCallTransformer extends ChronicleTransformer {
+    static source: string;
+    transform(record: Record): Promise<ActionAndChildren[]>;
+    private buildTimingCall;
+}
+//# sourceMappingURL=TimingCallTransformer.d.ts.map

package/dist/connectors/TimingCallTransformer.js

@@ -0,0 +1,158 @@
+import { ChronicleTransformer, normalizePhoneNumber } from '@chronicle.app/etl';
+import { lookupContact, lookupContactByName } from '@chronicle.app/icloud';
+// The call UUID is Apple's (relayed through Timing's Event.origin_id), so calls
+// key on `apple-call-history` + UUID and fold with the Apple Call History plugin's calls.
+const SOURCE = 'apple-call-history';
+/**
+ * Timing's relay of Apple Call History — the historical supplement for the long
+ * tail Apple has pruned (82% of Timing calls predate Apple's retention). Same
+ * shape as an Apple call. The party:
+ *   - unnamed contact (a raw handle)  → an `apple-call-history` party (folds via handle),
+ *   - named contact, resolvable       → the `apple-contacts` party,
+ *   - named contact, unresolvable     → no party; Timing's label rides on a
+ *       `sameAs`'d `timing-app` CallSession (a sourced fact, not a fabricated
+ *       Person, not the canonical session's own name).
+ *
+ * Caveat: Timing records no direction, so a resolved party goes on `recipient`
+ * (the best available slot). For a call that ALSO exists in Apple, Apple is
+ * authoritative for direction; this adds coverage for the pruned tail.
+ */
+export default class TimingCallTransformer extends ChronicleTransformer {
+    static source = SOURCE;
+    async transform(record) {
+        if (record.extraction.recordType === 'calls') {
+            return [this.buildTimingCall(record)];
+        }
+        return [];
+    }
+    buildTimingCall(record) {
+        const ctx = record.context;
+        const session = {
+            '@type': 'CallSession',
+            '@key': ['@type', 'source', 'sourceId'],
+            source: SOURCE,
+            sourceId: ctx.uuid,
+        };
+        if (ctx.handle) {
+            // A real calling handle → a proper party (folds via the handle).
+            const party = partyFromHandle(ctx.handle);
+            if (party)
+                session.recipient = [party];
+        }
+        else if (ctx.contactName) {
+            const party = partyFromContact(ctx.contactName);
+            if (party) {
+                session.recipient = [party];
+            }
+            else {
+                // Unresolvable name (ambiguous / no exact match): preserve Timing's label
+                // as a `sameAs`'d timing-app session node — a properly sourced fact, not a
+                // fabricated Person and not the canonical session's own name.
+                session.sameAs = [
+                    {
+                        '@type': 'CallSession',
+                        '@key': ['@type', 'source', 'sourceId'],
+                        source: 'timing-app',
+                        sourceId: ctx.uuid,
+                        name: ctx.contactName,
+                    },
+                ];
+            }
+        }
+        return {
+            '@type': 'CallAction',
+            '@key': ['@type', 'source', 'sourceId'],
+            source: SOURCE,
+            sourceId: ctx.uuid,
+            startTime: secondsToISO(ctx.startSec),
+            endTime: secondsToISO(ctx.endSec ?? ctx.startSec),
+            result: session,
+        };
+    }
+}
+/**
+ * An `apple-call-history` party from a calling handle (like the Apple plugin). Identity
+ * keys on the handle alone (`['source','handle']`); `@type` is an `Agent`
+ * annotation — a bare number could be a person or an org.
+ */
+function partyFromHandle(handle) {
+    const value = handle.trim();
+    if (!value)
+        return null;
+    const isEmail = value.includes('@');
+    const canonical = isEmail ? value.toLowerCase() : normalizePhoneNumber(value) || value;
+    const contact = lookupContact(canonical);
+    const party = {
+        '@type': 'Agent',
+        '@key': ['source', 'handle'],
+        source: 'apple-call-history',
+        handle: canonical,
+    };
+    if (contact?.fullName)
+        party.name = contact.fullName;
+    const sameAs = [
+        {
+            '@type': 'Agent',
+            '@key': ['source', 'handle'],
+            source: isEmail ? 'email' : 'phone',
+            handle: canonical,
+        },
+    ];
+    if (contact?.id)
+        sameAs.push(contactNode(contact));
+    party.sameAs = sameAs;
+    return party;
+}
+/**
+ * When Timing gives only a contact name (no number), the identity is the Address
+ * Book entry itself — `apple-contacts` primary, keyed on its stable id, with the
+ * contact's handles as `sameAs` (which is how it folds into the phone/email graph).
+ */
+function partyFromContact(name) {
+    // It's a call, so break a same-name tie by the phone-bearing card.
+    const contact = lookupContactByName(name, { preferPhone: true });
+    if (!contact?.id)
+        return null; // no stable identity → don't guess
+    const sameAs = [];
+    for (const phone of contact.phoneNumbers) {
+        sameAs.push({
+            '@type': 'Agent',
+            '@key': ['source', 'handle'],
+            source: 'phone',
+            handle: normalizePhoneNumber(phone) || phone,
+        });
+    }
+    for (const email of contact.emails) {
+        sameAs.push({
+            '@type': 'Agent',
+            '@key': ['source', 'handle'],
+            source: 'email',
+            handle: email.toLowerCase(),
+        });
+    }
+    const party = contactNode(contact);
+    if (sameAs.length > 0)
+        party.sameAs = sameAs;
+    return party;
+}
+/**
+ * The Address Book entry, keyed on its portable id and typed from the card (a
+ * person, or an org-only card → Organization) — the one place the kind is known.
+ */
+function contactNode(contact) {
+    const type = contact.firstName || contact.lastName
+        ? 'Person'
+        : contact.organization
+            ? 'Organization'
+            : 'Agent';
+    return {
+        '@type': type,
+        '@key': ['source', 'sourceId'],
+        source: 'apple-contacts',
+        sourceId: contact.id,
+        ...(contact.fullName ? { name: contact.fullName } : {}),
+    };
+}
+function secondsToISO(seconds) {
+    return new Date(seconds * 1000).toISOString();
+}

package/dist/connectors/TimingDbExtractor.d.ts

@@ -0,0 +1,40 @@
+import { SqliteExtractor } from '@chronicle.app/etl-sqlite';
+export declare const DEFAULT_DB: string;
+export declare const DEFAULT_WINDOW_DAYS = 90;
+export interface TimingDevice {
+    globalId: string;
+    name: string;
+    /** Real hardware MAC (Macs only); null for Screen-Time relayed devices. */
+    mac: string | null;
+    model: string | null;
+}
+export interface TimingProject {
+    id: string;
+    title: string;
+}
+/**
+ * Shared base for the extractors that read Timing.app's local SQLite: opens the
+ * DB read-only, pre-loads the small `Device`/`Project` lookups, and resolves the
+ * time window. `AppActivity` (6M+ rows) is streamed with a cursor by subclasses.
+ */
+export declare abstract class TimingDbExtractor<SelfClass extends typeof SqliteExtractor = typeof SqliteExtractor> extends SqliteExtractor<SelfClass> {
+    static delivery: "local";
+    static strategy: string;
+    static temporality: "event";
+    static schema: any;
+    /**
+     * Lower bound (epoch seconds): explicit `since`, else a default window, else
+     * none. An unbounded `--limit 0` also drops the window — asking for "no cap"
+     * is a request for a full backfill, not the newest 90 days without a count cap.
+     */
+    protected sinceSeconds(): number | null;
+    protected untilSeconds(): number | null;
+    protected loadDevices(): Map<string, TimingDevice>;
+    protected loadProjects(): Map<string, any>;
+    /** A resolver that nests a project's full ancestry (leaf-first) for a row. */
+    protected projectChainResolver(): (id: string | null) => TimingProject[];
+    protected countWindow(table: string, col: string, extra?: string): number;
+}
+/** A project's ancestry, leaf-first: [self, parent, grandparent, ...]. */
+export declare function resolveChain(projects: Map<string, any>, id: string | null): TimingProject[];
+//# sourceMappingURL=TimingDbExtractor.d.ts.map