@remnic/core 9.69.32 → 9.69.34

package/src/activity/journal-vault-read.ts

@@ -1,11 +1,17 @@
 /**
  * Read-only vault daily-note journal section (issue #1987 first slice).
  *
- * Pure: file text in, journal body out. Never writes. Strips Remnic-owned
- * marker regions and publisher-owned headings so published timeline text
- * cannot re-enter the journal. Path templates stay in vault-publish.
+ * Pure: caller supplies the file text (one read; the filesystem wrapper
+ * lives in journal-read.ts). Extracts the unique journal section via
+ * the shared ATX heading matcher, then strips every Remnic-owned region
+ * (journal-strip.ts) so published output can never re-enter the journal.
+ * Missing note and missing section are distinct, labeled no-journal
+ * outcomes (§22); duplicate headings refuse with line numbers.
  */
 
+import { parseAtxHeading } from "./journal-section.js";
+import { stripRemnicOwnedRegions } from "./journal-strip.js";
+
 export interface ReadVaultJournalInput {
   fileText: string | null | undefined;
   journalSection: string;
@@ -17,8 +23,6 @@ export type ReadVaultJournalResult =
   | { ok: true; exists: true; text: string; heading: string; warnings: readonly string[] }
   | { ok: false; reason: "duplicate_heading"; lines: readonly number[] };
 
-const REMNIC_OPEN = "<!-- remnic:";
-
 export function readVaultJournal(input: ReadVaultJournalInput): ReadVaultJournalResult {
   if (input.fileText === null || input.fileText === undefined) {
     return { ok: true, exists: false, reason: "missing_file" };
@@ -62,18 +66,6 @@ export function readVaultJournal(input: ReadVaultJournalInput): ReadVaultJournal
   };
 }
 
-/** Remove Remnic marker pairs and publisher-owned heading sections. */
-export function stripRemnicOwnedRegions(
-  text: string,
-  publishSectionNames: readonly string[] = [],
-): { text: string; warnings: readonly string[] } {
-  const marked = cutIntervals(text, remnicIntervals(text));
-  return {
-    text: stripPublishHeadings(marked.text, publishSectionNames),
-    warnings: marked.warnings,
-  };
-}
-
 function splitFileLines(fileText: string): string[] {
   const lines = fileText.split("\n");
   for (let i = 0; i < lines.length; i++) {
@@ -83,128 +75,6 @@ function splitFileLines(fileText: string): string[] {
   return lines;
 }
 
-function parseAtxHeading(line: string): { level: number; text: string } | null {
-  let level = 0;
-  while (level < line.length && level < 6 && line[level] === "#") level++;
-  if (level === 0) return null;
-  const after = line[level];
-  if (after !== " " && after !== "\t") return null;
-
-  let start = level + 1;
-  let end = line.length;
-  while (start < end && (line[start] === " " || line[start] === "\t")) start++;
-  while (end > start && (line[end - 1] === " " || line[end - 1] === "\t")) end--;
-
-  let hashEnd = end;
-  while (hashEnd > start && line[hashEnd - 1] === "#") hashEnd--;
-  if (hashEnd < end && hashEnd > start && (line[hashEnd - 1] === " " || line[hashEnd - 1] === "\t")) {
-    end = hashEnd;
-    while (end > start && (line[end - 1] === " " || line[end - 1] === "\t")) end--;
-  }
-  return { level, text: line.slice(start, end) };
-}
-
-function remnicIntervals(text: string): {
-  intervals: Array<{ start: number; end: number }>;
-  warnings: string[];
-} {
-  const starts: Array<{ name: string; start: number; after: number }> = [];
-  const ends: Array<{ name: string; start: number; end: number }> = [];
-
-  let from = 0;
-  while (from < text.length) {
-    const open = text.indexOf(REMNIC_OPEN, from);
-    if (open === -1) break;
-    const afterOpen = open + REMNIC_OPEN.length;
-    const commentEnd = text.indexOf("-->", afterOpen);
-    if (commentEnd === -1) break;
-    const inner = text.slice(afterOpen, commentEnd).trim();
-    if (inner.endsWith(":start")) {
-      const name = inner.slice(0, -":start".length);
-      if (name.length > 0) starts.push({ name, start: open, after: commentEnd + 3 });
-    } else if (inner.endsWith(":end")) {
-      const name = inner.slice(0, -":end".length);
-      if (name.length > 0) ends.push({ name, start: open, end: commentEnd + 3 });
-    }
-    from = commentEnd + 3;
-  }
-
-  const usedEnds = new Set<number>();
-  const intervals: Array<{ start: number; end: number }> = [];
-  const warnings: string[] = [];
-
-  for (const start of starts) {
-    const match = ends.find((end) => end.name === start.name && end.start >= start.after && !usedEnds.has(end.start));
-    if (match) {
-      usedEnds.add(match.start);
-      intervals.push({ start: start.start, end: eatTrailingNewline(text, match.end) });
-    } else {
-      intervals.push({ start: start.start, end: text.length });
-      warnings.push(`unclosed remnic region "${start.name}"`);
-    }
-  }
-
-  for (const end of ends) {
-    if (usedEnds.has(end.start)) continue;
-    const startBefore = starts.some((start) => start.start < end.start);
-    if (!startBefore) intervals.push({ start: 0, end: eatTrailingNewline(text, end.end) });
-  }
-
-  return { intervals: mergeIntervals(intervals), warnings };
-}
-
-function eatTrailingNewline(text: string, index: number): number {
-  if (text[index] === "\n") return index + 1;
-  if (text[index] === "\r" && text[index + 1] === "\n") return index + 2;
-  if (text[index] === "\r") return index + 1;
-  return index;
-}
-
-function mergeIntervals(items: Array<{ start: number; end: number }>): Array<{ start: number; end: number }> {
-  if (items.length === 0) return [];
-  const sorted = items.slice().sort((a, b) => a.start - b.start || a.end - b.end);
-  const out = [{ start: sorted[0]!.start, end: sorted[0]!.end }];
-  for (let i = 1; i < sorted.length; i++) {
-    const cur = sorted[i]!;
-    const last = out[out.length - 1]!;
-    if (cur.start <= last.end) last.end = Math.max(last.end, cur.end);
-    else out.push({ start: cur.start, end: cur.end });
-  }
-  return out;
-}
-
-function cutIntervals(
-  text: string,
-  found: { intervals: Array<{ start: number; end: number }>; warnings: string[] },
-): { text: string; warnings: string[] } {
-  let out = "";
-  let pos = 0;
-  for (const interval of found.intervals) {
-    if (interval.start > pos) out += text.slice(pos, interval.start);
-    pos = Math.max(pos, interval.end);
-  }
-  if (pos < text.length) out += text.slice(pos);
-  return { text: out, warnings: found.warnings };
-}
-
-function stripPublishHeadings(text: string, names: readonly string[]): string {
-  if (names.length === 0 || text.length === 0) return text;
-  const lines = text.split("\n");
-  const keep = lines.map(() => true);
-  for (let i = 0; i < lines.length; i++) {
-    if (!keep[i]) continue;
-    const heading = parseAtxHeading(lines[i]!);
-    if (!heading || !names.includes(heading.text)) continue;
-    keep[i] = false;
-    for (let j = i + 1; j < lines.length; j++) {
-      const next = parseAtxHeading(lines[j]!);
-      if (next && next.level <= heading.level) break;
-      keep[j] = false;
-    }
-  }
-  return lines.filter((_, i) => keep[i]).join("\n");
-}
-
 function trimNewlines(text: string): string {
   let start = 0;
   let end = text.length;

package/src/activity/journal.test.ts

@@ -32,44 +32,95 @@ test("activity.timeline.journal.enabled defaults off", () => {
   );
 });
 
-test("activity.timeline.journal source defaults to file with no heading", () => {
+test("activity.timeline.journal source defaults to memoryDir with extraction off", () => {
   const journal = parseActivityConfig(undefined).timeline.journal;
-  assert.equal(journal.source, "file");
-  assert.equal(journal.heading, undefined);
+  assert.deepEqual(journal, { enabled: false, source: "memoryDir", extractionMode: "off" });
 });
 
-test("activity.timeline.journal vault mode trims and stores the heading", () => {
-  const journal = parseActivityConfig({ timeline: { journal: { enabled: true, source: "vault", heading: " Journal " } } }).timeline.journal;
-  assert.deepEqual(journal, { enabled: true, source: "vault", heading: "Journal" });
+const VAULT_OK = {
+  enabled: true,
+  vaultPath: "/vault",
+  readback: { journalSection: "Journal" },
+};
+
+test("activity.timeline.journal vault mode parses with prerequisites satisfied", () => {
+  const journal = parseActivityConfig({
+    timeline: { journal: { enabled: true, source: "vault" }, vault: VAULT_OK },
+  }).timeline.journal;
+  assert.deepEqual(journal, { enabled: true, source: "vault", extractionMode: "off" });
 });
 
-test("activity.timeline.journal vault mode requires a non-empty heading", () => {
-  for (const heading of [undefined, "", "   "]) {
-    assert.throws(
-      () => parseActivityConfig({ timeline: { journal: { source: "vault", heading } } }),
-      RangeError,
-    );
+function captureError(fn: () => unknown): Error {
+  try {
+    fn();
+  } catch (err) {
+    return err as Error;
   }
+  throw new Error("expected parseActivityConfig to throw");
+}
+
+test("activity.timeline.journal vault mode names every missing prerequisite", () => {
+  const err = captureError(() => parseActivityConfig({ timeline: { journal: { source: "vault" } } }));
+  assert.ok(err instanceof RangeError);
+  assert.match(err.message, /vault\.readback\.journalSection/);
 });
 
-test("activity.timeline.journal rejects an unknown source", () => {
-  assert.throws(
-    () => parseActivityConfig({ timeline: { journal: { source: "memoryDir" } } }),
-    /activity\.timeline\.journal\.source must be one of "file", "vault"/,
+test("activity.timeline.journal vault mode with only the section set still names vault.enabled and dailyNotePath", () => {
+  const err = captureError(() =>
+    parseActivityConfig({
+      timeline: { journal: { source: "vault" }, vault: { readback: { journalSection: "Diary" } } },
+    }),
   );
+  assert.ok(err instanceof RangeError);
+  assert.doesNotMatch(err.message, /journalSection/);
+  assert.match(err.message, /vault\.enabled/);
+});
+
+test("activity.timeline.journal aliases source file to memoryDir", () => {
+  const journal = parseActivityConfig({ timeline: { journal: { source: "file" } } }).timeline.journal;
+  assert.equal(journal.source, "memoryDir");
 });
 
-test("activity.timeline.journal rejects a non-string heading", () => {
+test("activity.timeline.journal rejects an unknown source", () => {
   assert.throws(
-    () => parseActivityConfig({ timeline: { journal: { heading: 5 } } }),
-    /activity\.timeline\.journal\.heading must be a string/,
+    () => parseActivityConfig({ timeline: { journal: { source: "disk" } } }),
+    /activity\.timeline\.journal\.source must be one of "memoryDir", "vault"/,
   );
 });
 
-test("activity.timeline.journal file mode ignores a provided heading", () => {
-  const journal = parseActivityConfig({ timeline: { journal: { source: "file", heading: "Ignored" } } }).timeline.journal;
-  assert.deepEqual(journal, { enabled: false, source: "file" });
-  assert.equal("heading" in journal, false);
+test("activity.timeline.journal.heading fills vault.readback.journalSection when the new key is absent", () => {
+  const vault = parseActivityConfig({
+    timeline: { journal: { heading: "  Diary  " }, vault: { readback: { journalSection: "" } } },
+  }).timeline.vault;
+  assert.equal(vault.readback.journalSection, "Diary");
+});
+
+test("activity.timeline.vault.readback.journalSection wins over journal.heading", () => {
+  const vault = parseActivityConfig({
+    timeline: {
+      journal: { heading: "Diary" },
+      vault: { readback: { journalSection: "Journal" } },
+    },
+  }).timeline.vault;
+  assert.equal(vault.readback.journalSection, "Journal");
+});
+
+
+test("activity.timeline.journal extractionMode allows off and review only", () => {
+  for (const extractionMode of ["off", "review"]) {
+    const journal = parseActivityConfig({
+      timeline: { journal: { extractionMode } },
+    }).timeline.journal;
+    assert.equal(journal.extractionMode, extractionMode);
+  }
+  assert.throws(
+    () => parseActivityConfig({ timeline: { journal: { extractionMode: "auto" } } }),
+    /activity\.timeline\.journal\.extractionMode must be one of "off", "review"/,
+  );
+  assert.throws(
+    () => parseActivityConfig({ timeline: { journal: { extractionMode: "smart" } } }),
+    /activity\.timeline\.journal\.extractionMode must be one of "off", "review"/,
+  );
 });
 
 test("seed is a hard no-op without force", () => {

package/src/activity/runner.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { access, mkdtemp, readFile, rm } from "node:fs/promises";
+import { access, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
@@ -8,6 +8,7 @@ import { activityDatabasePath, ActivityStore } from "./store.js";
 import { activityDigestPath } from "./digest.js";
 import { runActivitySyncOnce } from "./runner.js";
 import { activityCursorKey } from "./pipeline.js";
+import { timelineDayPath } from "./timeline/regenerate.js";
 import { defaultActivityConfig } from "./config.js";
 import type {
   ActivityConfig,
@@ -490,3 +491,117 @@ test("runActivitySyncOnce reports every local date that gained snapshots (issue
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
+
+test("runActivitySyncOnce regenerates timeline analysis once per day", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-activity-runner-"));
+  const store = ActivityStore.open(memoryDir);
+  try {
+    const pages = new Map<string | null, ActivitySnapshotPage>([
+      [null, { snapshots: [snapshot()], nextCursor: null }],
+    ]);
+    const client = fixtureClient("workstation-a", pages);
+    let calls = 0;
+    const base = defaultActivityConfig();
+    const summary = await runActivitySyncOnce({
+      config: enabledConfig({
+        timeline: {
+          ...base.timeline,
+          enabled: true,
+          analysis: { enabled: true, provider: "openai", model: "gpt-test" },
+        },
+      }),
+      memoryDir,
+      store,
+      now: NOW,
+      createSourceClient: () => client,
+      analysisDeps: {
+        remoteLlm: {
+          chatCompletion: async () => {
+            calls += 1;
+            return { content: '{"ops":[]}' };
+          },
+        },
+      },
+    });
+    assert.equal(summary.ranCount, 1);
+    assert.equal(calls, 1);
+    await runActivitySyncOnce({
+      config: enabledConfig({
+        timeline: {
+          ...base.timeline,
+          enabled: true,
+          analysis: { enabled: true, provider: "openai", model: "gpt-test" },
+        },
+      }),
+      memoryDir,
+      store,
+      now: NOW,
+      createSourceClient: () => client,
+      analysisDeps: {
+        remoteLlm: {
+          chatCompletion: async () => {
+            calls += 1;
+            return { content: '{"ops":[]}' };
+          },
+        },
+      },
+    });
+    assert.equal(calls, 1, "second sync must not re-run analysis for unchanged evidence");
+  } finally {
+    store.close();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("next sync re-analyzes a pending day and does not repeat a failed analysis", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-activity-runner-"));
+  const store = ActivityStore.open(memoryDir);
+  try {
+    const pages = new Map<string | null, ActivitySnapshotPage>([
+      [null, { snapshots: [snapshot()], nextCursor: null }],
+    ]);
+    const client = fixtureClient("workstation-a", pages);
+    const base = defaultActivityConfig();
+    const analysis = { enabled: true, provider: "openai", model: "gpt-test" };
+    const syncOpts = {
+      config: enabledConfig({ timeline: { ...base.timeline, enabled: true, analysis } }),
+      memoryDir,
+      store,
+      now: NOW,
+      createSourceClient: () => client,
+      analysisDeps: {
+        remoteLlm: {
+          chatCompletion: async () => {
+            throw new Error("unused");
+          },
+        },
+      },
+    };
+    let calls = 0;
+    const okRemote = {
+      remoteLlm: {
+        chatCompletion: async (): Promise<{ content: string }> => {
+          calls += 1;
+          return { content: '{"ops":[]}' };
+        },
+      },
+    };
+    await runActivitySyncOnce({ ...syncOpts, analysisDeps: okRemote });
+    assert.equal(calls, 1);
+    const dayPath = timelineDayPath(memoryDir, "2026-07-22");
+    const persisted = JSON.parse(await readFile(dayPath, "utf8")) as { status: string };
+    // A crash after the deterministic prewrite leaves "pending" on disk.
+    persisted.status = "pending";
+    await writeFile(dayPath, `${JSON.stringify(persisted)}\n`);
+    await runActivitySyncOnce({ ...syncOpts, analysisDeps: okRemote });
+    assert.equal(calls, 2, "a pending prewrite must be re-analyzed by the next sync");
+    // A completed provider failure is terminal: no repeated spend.
+    persisted.status = "provider_failed";
+    await writeFile(dayPath, `${JSON.stringify(persisted)}\n`);
+    await runActivitySyncOnce({ ...syncOpts, analysisDeps: okRemote });
+    assert.equal(calls, 2, "a completed provider failure must not repeat the provider call");
+  } finally {
+    store.close();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/activity/runner.ts

@@ -26,7 +26,9 @@ import { syncActivitySource } from "./pipeline.js";
 import { ActivityHttpSourceClient } from "./source-client.js";
 import { activityDateInTimezone } from "./digest.js";
 import { displayErrorDetail } from "../runtime/better-sqlite.js";
+import type { PluginConfig } from "../types.js";
 import type { ActivityConfig, ActivitySourceClient, ActivitySourceConfig } from "./types.js";
+import { regenerateTimelineDay, type TimelineAnalysisClients } from "./timeline/regenerate.js";
 
 type ActivityNow = Date | (() => Date);
 
@@ -86,6 +88,10 @@ export interface ActivitySyncRunOptions {
    * Host wires the core index seam (SearchBackend.update); best-effort.
    */
   reindexSearch?: (signal?: AbortSignal) => Promise<void>;
+  /** Full plugin config so regenerate can construct local/remote LLM clients. */
+  pluginConfig?: PluginConfig;
+  /** Injected analysis clients; tests and hosts that already own them. */
+  analysisDeps?: TimelineAnalysisClients;
 }
 
 /** Previous calendar date via pure date arithmetic (no DST wall-clock drift). */
@@ -217,6 +223,25 @@ export async function runActivitySyncOnce(options: ActivitySyncRunOptions): Prom
       // a client or contacts a daemon — teardown settles promptly.
       if (options.signal?.aborted) break;
     }
+    if (options.config.timeline.enabled && !options.signal?.aborted) {
+      for (const date of dates) {
+        try {
+          await regenerateTimelineDay({
+            date,
+            timezone: options.config.timezone,
+            memoryDir: options.memoryDir,
+            store,
+            timelineEnabled: true,
+            analysis: options.config.timeline.analysis,
+            ...(options.pluginConfig === undefined ? {} : { pluginConfig: options.pluginConfig }),
+            ...(options.analysisDeps === undefined ? {} : { deps: options.analysisDeps }),
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+          });
+        } catch {
+          // Analysis/persist faults must not fail the durable sync.
+        }
+      }
+    }
   } finally {
     if (ownStore) store.close();
   }

package/src/activity/scheduler.ts

@@ -18,6 +18,7 @@
  */
 
 import { runActivitySyncOnce, type ActivitySyncRunSummary } from "./runner.js";
+import type { PluginConfig } from "../types.js";
 import type { ActivityConfig } from "./types.js";
 
 /**
@@ -47,6 +48,8 @@ export interface ActivitySyncSchedulerOptions {
   onRun?: (summary: ActivitySyncRunSummary) => void;
   /** Called when a tick's sync rejects; defaults to swallowing (best-effort). */
   onError?: (error: unknown) => void;
+  /** Full plugin config forwarded to the default runner for analysis clients. */
+  pluginConfig?: PluginConfig;
 }
 
 export interface ActivitySyncRegistration {
@@ -88,6 +91,7 @@ export class ActivitySyncScheduler {
           memoryDir: this.memoryDir,
           signal,
           ...(options.reindexSearch === undefined ? {} : { reindexSearch: options.reindexSearch }),
+          ...(options.pluginConfig === undefined ? {} : { pluginConfig: options.pluginConfig }),
         }));
     this.setTimer =
       options.setTimer ??

package/src/activity/store.test.ts

@@ -224,3 +224,21 @@ test("insertSnapshot rejects an unknown textSource", async () => {
     assert.throws(() => store.insertSnapshot(snapshot({ textSource: "screen" as unknown as "ax" })), RangeError);
   });
 });
+
+test("snapshotCaptureExtent is null on an empty store", async () => {
+  await withStore((store) => {
+    assert.equal(store.snapshotCaptureExtent(), null);
+  });
+});
+
+test("snapshotCaptureExtent returns the min and max capture instants", async () => {
+  await withStore((store) => {
+    store.insertSnapshot(snapshot({ contentHash: "mid", capturedAtUtc: "2026-03-10T14:00:00.000Z" }));
+    store.insertSnapshot(snapshot({ contentHash: "old", capturedAtUtc: "2026-02-01T09:00:00.000Z" }));
+    store.insertSnapshot(snapshot({ contentHash: "new", capturedAtUtc: "2026-05-20T23:00:00.000Z" }));
+    assert.deepEqual(store.snapshotCaptureExtent(), {
+      firstUtc: "2026-02-01T09:00:00.000Z",
+      lastUtc: "2026-05-20T23:00:00.000Z",
+    });
+  });
+});

package/src/activity/store.ts

@@ -346,6 +346,20 @@ export class ActivityStore {
     return ids.length;
   }
 
+  /**
+   * First and last stored capture instants (canonical UTC strings), or null
+   * when no snapshots exist. Backs the unbounded timeline search window.
+   */
+  snapshotCaptureExtent(): { firstUtc: string; lastUtc: string } | null {
+    const row = this.db
+      .prepare("SELECT MIN(captured_at_utc) AS first, MAX(captured_at_utc) AS last FROM activity_snapshots")
+      .get();
+    if (!isRecord(row) || typeof row.first !== "string" || typeof row.last !== "string") {
+      return null;
+    }
+    return { firstUtc: row.first, lastUtc: row.last };
+  }
+
   close(): void {
     this.db.close();
   }

package/src/activity/sync-registration.ts

@@ -25,6 +25,7 @@
 import { refreshActivityIndex, type ActivityIndexRefresher } from "./reindex.js";
 import type { ActivitySyncRunSummary } from "./runner.js";
 import { ActivitySyncScheduler, type ActivitySyncSchedulerOptions } from "./scheduler.js";
+import type { PluginConfig } from "../types.js";
 import type { ActivityConfig } from "./types.js";
 import { log } from "../logger.js";
 
@@ -59,6 +60,8 @@ export interface ActivitySyncRegistrarDeps {
   readonly onSynced?: (summary: ActivitySyncRunSummary) => void;
   /** Scheduler factory (injectable for tests); defaults to the real scheduler. */
   readonly createScheduler?: (options: ActivitySyncSchedulerOptions) => ActivitySyncSchedulerLike;
+  /** Full plugin config so the default runner can build analysis clients. */
+  readonly pluginConfig?: PluginConfig;
 }
 
 export class ActivitySyncRegistrar {
@@ -108,6 +111,7 @@ export class ActivitySyncRegistrar {
         // Strict refresh after each digest write (rule 31): bypasses the
         // min-interval gate and throws on a real failure.
         reindexSearch: (sig) => refreshActivityIndex(this.deps.getQmd(), this.deps.qmdCollection, sig),
+        ...(this.deps.pluginConfig === undefined ? {} : { pluginConfig: this.deps.pluginConfig }),
         // A failed reindex (QMD down) leaves the next unchanged-digest tick
         // skipping afterWrites, so route the retry through the durable,
         // throttled QMD path — but never after teardown.

package/src/activity/timeline/analysis-metadata.ts

@@ -20,6 +20,8 @@ export interface AnalysisRunMetadata {
 }
 
 export const ANALYSIS_METADATA_MAX_FIELD_LENGTH = 120;
+/** True when value is an identifier-safe provider/model/promptVersion string. */
+export const isAnalysisIdentifier = (value: string): boolean => IDENTIFIER.test(value);
 
 /**
  * Identifier syntax for provider and model: letters, digits, and the