opencode-graphiti 0.2.0-canary.f9dde2d.20260319200335 → 0.2.0

package/README.md

@@ -77,6 +77,44 @@ Graphiti stays off the steady-state hook path entirely: hook-time injection uses
 only Redis/local cached recall, while fresh Graphiti data arrives through the
 existing background refresh path on later turns.
 
+### MCP-First Execution Surface
+
+The plugin exposes a set of `session_*` MCP tools as the **primary execution
+surface** for data-heavy work. These tools run in-process alongside the plugin
+hooks and share the same canonical root-session identity and Redis/FalkorDB hot
+tier.
+
+The `session_*` tools also write into the same local continuity model as the
+rest of the session: their bounded summaries are recorded as structured events,
+folded into the local snapshot, and preserved through compaction under the same
+`<session_memory>` envelope used for ordinary chat continuity.
+
+- **Bounded execution** (`session_execute`, `session_execute_file`,
+  `session_batch_execute`) — run commands or process files locally, store full
+  output in the local corpus, and return only a bounded summary to the model.
+  `session_batch_execute` supports ordered mixed steps, so one request can
+  combine bounded command execution with local corpus search.
+- **Local indexing and search** (`session_index`, `session_search`,
+  `session_fetch_and_index`) — index content into a per-session local corpus in
+  Redis/FalkorDB and search it with bounded result sets. The local corpus stays
+  local-first: indexing and retrieval happen against the session's local store,
+  while any Graphiti augmentation remains asynchronous and cache-backed.
+  `session_index` accepts either inline `content` or a local `path`; when the
+  same `source` and `label` are indexed again for one root session, the prior
+  logical document is replaced instead of appended.
+- **Diagnostics** (`session_stats`, `session_doctor`) — inspect session state
+  and corpus health.
+
+The plugin hooks enforce this preference: when the model falls back to risky
+native tools (e.g. unbounded `WebFetch` or raw `curl`), the hook layer may
+redirect or deny the call and suggest the corresponding `session_*` tool. Hooks
+remain secondary — they handle enforcement, continuity capture, snapshot
+assembly, and `<session_memory>` injection, but are not the primary execution
+path.
+
+For the full MCP-first architecture, see
+`docs/superpowers/plans/2026-03-20-context-mode-mcp-first.md`.
+
 ## Prerequisites
 
 Start the
@@ -107,6 +145,10 @@ long-term knowledge graph on top of the same backend.
 
 Add the plugin to your `opencode.json` (or `opencode.jsonc`):
 
+The package root intentionally exports only the `graphiti` plugin entrypoint.
+Helper symbols under `src/` are internal implementation details and are not a
+supported public import surface.
+
 ```jsonc
 {
   "plugin": ["opencode-graphiti"]
@@ -117,8 +159,9 @@ Add the plugin to your `opencode.json` (or `opencode.jsonc`):
 
 Local distributable builds are not a routine local setup step: `deno task
 build`
-requires an explicit `VERSION` via `dnt.ts`. If you already have a built
-artifact, add it to your `opencode.json`:
+uses the `VERSION` environment variable when set and otherwise falls back to the
+`version` in `deno.json` via `dnt.ts`. If you already have a built artifact, add
+it to your `opencode.json`:
 
 ```jsonc
 {
@@ -192,6 +235,15 @@ top-level aliases remain supported for backward compatibility. Precedence is:
 1. `redis.*` (canonical)
 2. top-level Graphiti aliases such as `endpoint` and `groupIdPrefix`
 
+Endpoint values must resolve to valid URLs. The loader applies best-effort
+coercion for endpoint-like inputs by trimming whitespace, adding the expected
+scheme when omitted, and filling the default port only when a missing-scheme
+input also omits a port. For example, `localhost` under `redis.endpoint`
+resolves to `redis://localhost:6379`, `cache.internal:6380` resolves to
+`redis://cache.internal:6380`, and `graphiti.internal/mcp` under
+`graphiti.endpoint` resolves to `http://graphiti.internal:8000/mcp`. Inputs that
+still fail URL parsing, or that use a disallowed explicit scheme, are rejected.
+
 ### Legacy Top-Level Keys
 
 For backward compatibility, the following original Graphiti top-level keys are
@@ -209,17 +261,20 @@ Removed top-level Redis aliases are no longer supported.
 
 ### Injection Format
 
-The plugin currently injects a `<session_memory>` XML envelope into the last
-user message. This envelope is assembled from short-term memory in Redis and can
-contain structured sections such as `<last_request>`, `<active_tasks>`,
-`<key_decisions>`, `<files_in_play>`, `<project_rules>`, and an optional
-`<session_snapshot>`.
-
-When long-term memory is available, a nested `<persistent_memory>` section is
-included with a `node_refs` attribute naming the emitted cached entities. On a
-cold first turn or when Graphiti is unreachable, `<persistent_memory>` is simply
-absent — the rest of the session memory is always available from short-term
-storage in FalkorDB/Redis.
+The plugin injects a **local-first** `<session_memory>` XML envelope into the
+last user message. Every section except `<persistent_memory>` is assembled
+entirely from Redis/FalkorDB state — no external service is on the synchronous
+path.
+
+- **Local continuity sections** (`<last_request>`, `<active_tasks>`,
+  `<key_decisions>`, `<files_in_play>`, `<project_rules>`, etc.) are derived
+  from structured session events stored in Redis/FalkorDB.
+- **`<session_snapshot>`** is produced by the local snapshot service, which
+  continuously rebuilds a priority-tiered summary from those events.
+- **`<persistent_memory>`** is an **optional, cache-only** augmentation. When
+  Graphiti-sourced facts are cached locally, they are included; on a cold first
+  turn or when Graphiti is unreachable, this section is simply absent. It never
+  blocks the current turn.
 
 ```xml
 <session_memory source="graphiti" version="1">
@@ -237,17 +292,18 @@ storage in FalkorDB/Redis.
 
 ### Session Memory Preparation (`chat.message`)
 
-On each user message the plugin assembles the current session memory from three
-sources:
+On each user message the plugin assembles the current session memory from
+local-only sources:
 
-- Recent structured session events
-- The continuously rebuilt priority-tiered snapshot
-- Cached long-term facts from Graphiti
+- **Session events** stored in Redis/FalkorDB
+- **Priority-tiered snapshot** rebuilt by the local snapshot service
+- **Cached Graphiti facts** (optional; read from the local Redis cache, never
+  from a synchronous Graphiti call)
 
 These are composed into a `<session_memory>` envelope and staged for the
-transform hook. The hook-time reads are local/cache-backed only; any fresh
-Graphiti lookup remains on the existing background refresh path and benefits the
-next turn instead of blocking the current one.
+transform hook. All reads are local/cache-backed; Graphiti is never called
+synchronously. Any fresh Graphiti lookup remains on the existing background
+refresh path and benefits the next turn instead of blocking the current one.
 
 ### User Message Injection (`experimental.chat.messages.transform`)
 
@@ -281,8 +337,9 @@ Events are also queued for background ingestion into long-term memory:
 
 - **On idle** (`session.idle`): buffered events are sent to Graphiti and the
   priority-tiered snapshot is rebuilt.
-- **Before compaction** (`session.compacted`): all pending events are sent
-  immediately so nothing is lost.
+- **After compaction** (`session.compacted`): the compaction summary and any
+  pending continuity are scheduled for background Graphiti ingestion so nothing
+  is lost across compaction boundaries.
 
 ### Compaction Preservation
 
@@ -308,7 +365,7 @@ regardless of how aggressively the conversation was summarized.
 > work as summarized tool events. This plugin promotes child sessions to
 > first-class participants in the root session's state so that decisions, file
 > edits, and errors from delegated work are fully visible to the parent session.
-> See `plans/ContextOverhaul.md` §10.1 for the design rationale.
+> See `docs/ContextOverhaul.md` §11.1 for the design rationale.
 
 When OpenCode spawns a child session (e.g. a subagent or delegated task), the
 plugin resolves the child's `sessionID` to the root/parent session by walking

package/esm/_dnt.polyfills.d.ts

@@ -1,3 +1,9 @@
+declare global {
+    interface Error {
+        cause?: unknown;
+    }
+}
+export {};
 declare global {
     interface Array<T> {
         /**
@@ -58,12 +64,6 @@ declare global {
     }
 }
 export {};
-declare global {
-    interface Error {
-        cause?: unknown;
-    }
-}
-export {};
 /**
  * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
  * but instead of using npm to install additional dependencies,

package/esm/_dnt.polyfills.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"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"}

package/esm/deno.d.ts

@@ -6,7 +6,6 @@ declare namespace _default {
     export namespace tasks {
         let build: string;
         let check: string;
-        let deploy: string;
         let dev: string;
         let lint: string;
         let fmt: string;

package/esm/deno.js

@@ -6,7 +6,6 @@ export default {
     "tasks": {
         "build": "deno run -A dnt.ts",
         "check": "deno check src/index.ts",
-        "deploy": "deno eval \"throw new Error('Manual publish is disabled. Use the GitHub Actions publish workflow for releases.')\"",
         "dev": "deno run --allow-all src/index.ts",
         "lint": "deno lint",
         "fmt": "deno fmt"

package/esm/deps/jsr.io/@std/ulid/1.0.0/_util.d.ts

@@ -0,0 +1,14 @@
+/** Type for a ULID generator function. */
+export type ULID = (seedTime?: number) => string;
+export declare const ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+export declare const ENCODING_LEN: number;
+export declare const TIME_MAX: number;
+export declare const TIME_LEN = 10;
+export declare const RANDOM_LEN = 16;
+export declare const ULID_LEN: number;
+export declare function encodeTime(timestamp: number): string;
+export declare function encodeRandom(): string;
+export declare function incrementBase32(str: string): string;
+/** Generates a monotonically increasing ULID. */
+export declare function monotonicFactory(encodeRand?: typeof encodeRandom): ULID;
+//# sourceMappingURL=_util.d.ts.map

package/esm/deps/jsr.io/@std/ulid/1.0.0/_util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_util.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/ulid/1.0.0/_util.ts"],"names":[],"mappings":"AAEA,0CAA0C;AAC1C,MAAM,MAAM,IAAI,GAAG,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;AAIjD,eAAO,MAAM,QAAQ,qCAAqC,CAAC;AAC3D,eAAO,MAAM,YAAY,QAAkB,CAAC;AAC5C,eAAO,MAAM,QAAQ,QAAsB,CAAC;AAC5C,eAAO,MAAM,QAAQ,KAAK,CAAC;AAC3B,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,eAAO,MAAM,QAAQ,QAAwB,CAAC;AAM9C,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAapD;AAED,wBAAgB,YAAY,IAAI,MAAM,CAOrC;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAkBnD;AAED,iDAAiD;AACjD,wBAAgB,gBAAgB,CAAC,UAAU,sBAAe,GAAG,IAAI,CAYhE"}

package/esm/deps/jsr.io/@std/ulid/1.0.0/_util.js

@@ -0,0 +1,65 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// These values should NEVER change. If
+// they do, we're no longer making ulids!
+export const ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"; // Crockford's Base32
+export const ENCODING_LEN = ENCODING.length;
+export const TIME_MAX = Math.pow(2, 48) - 1;
+export const TIME_LEN = 10;
+export const RANDOM_LEN = 16;
+export const ULID_LEN = TIME_LEN + RANDOM_LEN;
+function replaceCharAt(str, index, char) {
+    return str.substring(0, index) + char + str.substring(index + 1);
+}
+export function encodeTime(timestamp) {
+    if (!Number.isInteger(timestamp) || timestamp < 0 || timestamp > TIME_MAX) {
+        throw new RangeError(`Time must be a positive integer less than ${TIME_MAX}`);
+    }
+    let str = "";
+    for (let len = TIME_LEN; len > 0; len--) {
+        const mod = timestamp % ENCODING_LEN;
+        str = ENCODING[mod] + str;
+        timestamp = Math.floor(timestamp / ENCODING_LEN);
+    }
+    return str;
+}
+export function encodeRandom() {
+    let str = "";
+    const bytes = crypto.getRandomValues(new Uint8Array(RANDOM_LEN));
+    for (const byte of bytes) {
+        str += ENCODING[byte % ENCODING_LEN];
+    }
+    return str;
+}
+export function incrementBase32(str) {
+    let index = str.length;
+    let char;
+    let charIndex;
+    const maxCharIndex = ENCODING_LEN - 1;
+    while (--index >= 0) {
+        char = str[index];
+        charIndex = ENCODING.indexOf(char);
+        if (charIndex === -1) {
+            throw new TypeError("Incorrectly encoded string");
+        }
+        if (charIndex === maxCharIndex) {
+            str = replaceCharAt(str, index, ENCODING[0]);
+            continue;
+        }
+        return replaceCharAt(str, index, ENCODING[charIndex + 1]);
+    }
+    throw new Error("Cannot increment this string");
+}
+/** Generates a monotonically increasing ULID. */
+export function monotonicFactory(encodeRand = encodeRandom) {
+    let lastTime = 0;
+    let lastRandom;
+    return function ulid(seedTime = Date.now()) {
+        if (seedTime <= lastTime) {
+            const incrementedRandom = (lastRandom = incrementBase32(lastRandom));
+            return encodeTime(lastTime) + incrementedRandom;
+        }
+        lastTime = seedTime;
+        const newRandom = (lastRandom = encodeRand());
+        return encodeTime(seedTime) + newRandom;
+    };
+}

package/esm/deps/jsr.io/@std/ulid/1.0.0/decode_time.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Extracts the number of milliseconds since the Unix epoch that had passed when
+ * the ULID was generated. If the ULID is malformed, an error will be thrown.
+ *
+ * @example Decode the time from a ULID
+ * ```ts
+ * import { decodeTime, ulid } from "@std/ulid";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const timestamp = 150_000;
+ * const ulidString = ulid(timestamp);
+ *
+ * assertEquals(decodeTime(ulidString), timestamp);
+ * ```
+ *
+ * @param ulid The ULID to extract the timestamp from.
+ * @returns The number of milliseconds since the Unix epoch that had passed when the ULID was generated.
+ */
+export declare function decodeTime(ulid: string): number;
+//# sourceMappingURL=decode_time.d.ts.map

package/esm/deps/jsr.io/@std/ulid/1.0.0/decode_time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode_time.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/ulid/1.0.0/decode_time.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAqB/C"}

package/esm/deps/jsr.io/@std/ulid/1.0.0/decode_time.js

@@ -0,0 +1,43 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright 2023 Yoshiya Hinosawa. All rights reserved. MIT license.
+// Copyright 2017 Alizain Feerasta. All rights reserved. MIT license.
+// This module is browser compatible.
+import { ENCODING, ENCODING_LEN, TIME_LEN, TIME_MAX, ULID_LEN, } from "./_util.js";
+/**
+ * Extracts the number of milliseconds since the Unix epoch that had passed when
+ * the ULID was generated. If the ULID is malformed, an error will be thrown.
+ *
+ * @example Decode the time from a ULID
+ * ```ts
+ * import { decodeTime, ulid } from "@std/ulid";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const timestamp = 150_000;
+ * const ulidString = ulid(timestamp);
+ *
+ * assertEquals(decodeTime(ulidString), timestamp);
+ * ```
+ *
+ * @param ulid The ULID to extract the timestamp from.
+ * @returns The number of milliseconds since the Unix epoch that had passed when the ULID was generated.
+ */
+export function decodeTime(ulid) {
+    if (ulid.length !== ULID_LEN) {
+        throw new Error(`ULID must be exactly ${ULID_LEN} characters long`);
+    }
+    const time = ulid
+        .substring(0, TIME_LEN)
+        .split("")
+        .reverse()
+        .reduce((carry, char, index) => {
+        const encodingIndex = ENCODING.indexOf(char);
+        if (encodingIndex === -1) {
+            throw new Error(`Invalid ULID character found: ${char}`);
+        }
+        return (carry += encodingIndex * Math.pow(ENCODING_LEN, index));
+    }, 0);
+    if (time > TIME_MAX) {
+        throw new RangeError(`ULID timestamp component exceeds maximum value of ${TIME_MAX}`);
+    }
+    return time;
+}

package/esm/deps/jsr.io/@std/ulid/1.0.0/mod.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Utilities for generating and working with
+ * {@link https://github.com/ulid/spec | Universally Unique Lexicographically Sortable Identifiers (ULIDs)}.
+ *
+ * To generate a ULID use the {@linkcode ulid} function. This will generate a
+ * ULID based on the current time.
+ *
+ * ```ts no-assert
+ * import { ulid } from "@std/ulid";
+ *
+ * ulid(); // 01HYFKMDF3HVJ4J3JZW8KXPVTY
+ * ```
+ *
+ * {@linkcode ulid} does not guarantee that the ULIDs will be strictly
+ * increasing for the same current time. If you need to guarantee that the ULIDs
+ * will be strictly increasing, even for the same current time, use the
+ * {@linkcode monotonicUlid} function.
+ *
+ * ```ts no-assert
+ * import { monotonicUlid } from "@std/ulid";
+ *
+ * monotonicUlid(); // 01HYFKHG5F8RHM2PM3D7NSTDAS
+ * monotonicUlid(); // 01HYFKHG5F8RHM2PM3D7NSTDAT
+ * ```
+ *
+ * Because each ULID encodes the time it was generated, you can extract the
+ * timestamp from a ULID using the {@linkcode decodeTime} function.
+ *
+ * ```ts
+ * import { decodeTime, ulid } from "@std/ulid";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const timestamp = 150_000;
+ * const ulidString = ulid(timestamp);
+ *
+ * assertEquals(decodeTime(ulidString), timestamp);
+ * ```
+ *
+ * @module
+ */
+export * from "./decode_time.js";
+export * from "./monotonic_ulid.js";
+export * from "./ulid.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/deps/jsr.io/@std/ulid/1.0.0/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/ulid/1.0.0/mod.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC"}

package/esm/deps/jsr.io/@std/ulid/1.0.0/mod.js

@@ -0,0 +1,47 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright 2023 Yoshiya Hinosawa. All rights reserved. MIT license.
+// Copyright 2017 Alizain Feerasta. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * Utilities for generating and working with
+ * {@link https://github.com/ulid/spec | Universally Unique Lexicographically Sortable Identifiers (ULIDs)}.
+ *
+ * To generate a ULID use the {@linkcode ulid} function. This will generate a
+ * ULID based on the current time.
+ *
+ * ```ts no-assert
+ * import { ulid } from "@std/ulid";
+ *
+ * ulid(); // 01HYFKMDF3HVJ4J3JZW8KXPVTY
+ * ```
+ *
+ * {@linkcode ulid} does not guarantee that the ULIDs will be strictly
+ * increasing for the same current time. If you need to guarantee that the ULIDs
+ * will be strictly increasing, even for the same current time, use the
+ * {@linkcode monotonicUlid} function.
+ *
+ * ```ts no-assert
+ * import { monotonicUlid } from "@std/ulid";
+ *
+ * monotonicUlid(); // 01HYFKHG5F8RHM2PM3D7NSTDAS
+ * monotonicUlid(); // 01HYFKHG5F8RHM2PM3D7NSTDAT
+ * ```
+ *
+ * Because each ULID encodes the time it was generated, you can extract the
+ * timestamp from a ULID using the {@linkcode decodeTime} function.
+ *
+ * ```ts
+ * import { decodeTime, ulid } from "@std/ulid";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const timestamp = 150_000;
+ * const ulidString = ulid(timestamp);
+ *
+ * assertEquals(decodeTime(ulidString), timestamp);
+ * ```
+ *
+ * @module
+ */
+export * from "./decode_time.js";
+export * from "./monotonic_ulid.js";
+export * from "./ulid.js";

package/esm/deps/jsr.io/@std/ulid/1.0.0/monotonic_ulid.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Generate a ULID that monotonically increases even for the same millisecond,
+ * optionally passing the current time. If the current time is not passed, it
+ * will default to `Date.now()`.
+ *
+ * Unlike the {@linkcode ulid} function, this function is guaranteed to return
+ * strictly increasing ULIDs, even for the same seed time, but only if the seed
+ * time only ever increases. If the seed time ever goes backwards, the ULID will
+ * still be generated, but it will not be guaranteed to be monotonic with
+ * previous ULIDs for that same seed time.
+ *
+ * @example Generate a monotonic ULID
+ * ```ts no-assert
+ * import { monotonicUlid } from "@std/ulid";
+ *
+ * monotonicUlid(); // 01HYFKHG5F8RHM2PM3D7NSTDAS
+ * monotonicUlid(); // 01HYFKHG5F8RHM2PM3D7NSTDAT
+ * monotonicUlid(); // 01HYFKHHX8H4BRY8BYHAV1BZ2T
+ * ```
+ *
+ * @example Generate a monotonic ULID with a seed time
+ * ```ts no-assert
+ * import { monotonicUlid } from "@std/ulid";
+ *
+ * // Strict ordering for the same timestamp, by incrementing the least-significant random bit by 1
+ * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1Q
+ * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1R
+ * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1S
+ * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1T
+ * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1U
+ *
+ * // A different timestamp will reset the random bits
+ * monotonicUlid(150001); // 0000004JFHJJ2Z7X64FN2B4F1P
+ *
+ * // A previous seed time will not guarantee ordering, and may result in a
+ * // ULID lower than one with the same seed time generated previously
+ * monotonicUlid(150000); // 0000004JFJ7XF6D76ES95SZR0X
+ * ```
+ *
+ * @param seedTime The time to base the ULID on, in milliseconds since the Unix epoch. Defaults to `Date.now()`.
+ * @returns A ULID that is guaranteed to be strictly increasing for the same seed time.
+ */
+export declare function monotonicUlid(seedTime?: number): string;
+//# sourceMappingURL=monotonic_ulid.d.ts.map

package/esm/deps/jsr.io/@std/ulid/1.0.0/monotonic_ulid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monotonic_ulid.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/ulid/1.0.0/monotonic_ulid.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,aAAa,CAAC,QAAQ,GAAE,MAAmB,GAAG,MAAM,CAEnE"}

package/esm/deps/jsr.io/@std/ulid/1.0.0/monotonic_ulid.js

@@ -0,0 +1,51 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright 2023 Yoshiya Hinosawa. All rights reserved. MIT license.
+// Copyright 2017 Alizain Feerasta. All rights reserved. MIT license.
+// This module is browser compatible.
+import { monotonicFactory } from "./_util.js";
+const defaultMonotonicUlid = monotonicFactory();
+/**
+ * Generate a ULID that monotonically increases even for the same millisecond,
+ * optionally passing the current time. If the current time is not passed, it
+ * will default to `Date.now()`.
+ *
+ * Unlike the {@linkcode ulid} function, this function is guaranteed to return
+ * strictly increasing ULIDs, even for the same seed time, but only if the seed
+ * time only ever increases. If the seed time ever goes backwards, the ULID will
+ * still be generated, but it will not be guaranteed to be monotonic with
+ * previous ULIDs for that same seed time.
+ *
+ * @example Generate a monotonic ULID
+ * ```ts no-assert
+ * import { monotonicUlid } from "@std/ulid";
+ *
+ * monotonicUlid(); // 01HYFKHG5F8RHM2PM3D7NSTDAS
+ * monotonicUlid(); // 01HYFKHG5F8RHM2PM3D7NSTDAT
+ * monotonicUlid(); // 01HYFKHHX8H4BRY8BYHAV1BZ2T
+ * ```
+ *
+ * @example Generate a monotonic ULID with a seed time
+ * ```ts no-assert
+ * import { monotonicUlid } from "@std/ulid";
+ *
+ * // Strict ordering for the same timestamp, by incrementing the least-significant random bit by 1
+ * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1Q
+ * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1R
+ * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1S
+ * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1T
+ * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1U
+ *
+ * // A different timestamp will reset the random bits
+ * monotonicUlid(150001); // 0000004JFHJJ2Z7X64FN2B4F1P
+ *
+ * // A previous seed time will not guarantee ordering, and may result in a
+ * // ULID lower than one with the same seed time generated previously
+ * monotonicUlid(150000); // 0000004JFJ7XF6D76ES95SZR0X
+ * ```
+ *
+ * @param seedTime The time to base the ULID on, in milliseconds since the Unix epoch. Defaults to `Date.now()`.
+ * @returns A ULID that is guaranteed to be strictly increasing for the same seed time.
+ */
+export function monotonicUlid(seedTime = Date.now()) {
+    return defaultMonotonicUlid(seedTime);
+}

package/esm/deps/jsr.io/@std/ulid/1.0.0/ulid.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Generate a ULID, optionally based on a given timestamp. If the timestamp is
+ * not passed, it will default to `Date.now()`.
+ *
+ * Multiple calls to this function with the same seed time will not guarantee
+ * that the ULIDs will be strictly increasing, even if the seed time is the
+ * same. For that, use the {@linkcode monotonicUlid} function.
+ *
+ * @example Generate a ULID
+ * ```ts no-assert
+ * import { ulid } from "@std/ulid";
+ *
+ * ulid(); // 01HYFKMDF3HVJ4J3JZW8KXPVTY
+ * ulid(); // 01HYFKMDF3D2P7G502B9Z2VKV0
+ * ulid(); // 01HYFKMDZQ7JD17CRKDXQSZ3Z4
+ * ```
+ *
+ * @example Generate a ULID with a seed time
+ * ```ts no-assert
+ * import { ulid } from "@std/ulid";
+ *
+ * ulid(150000); // 0000004JFG3EKDRE04TVVDJW7K
+ * ulid(150000); // 0000004JFGN0KHBH0447AK895X
+ * ulid(150000); // 0000004JFGMRDH0PN7SM8BZN06
+ * ```
+ *
+ * @param seedTime The time to base the ULID on, in milliseconds since the Unix epoch. Defaults to `Date.now()`.
+ * @returns A ULID.
+ */
+export declare function ulid(seedTime?: number): string;
+//# sourceMappingURL=ulid.d.ts.map

package/esm/deps/jsr.io/@std/ulid/1.0.0/ulid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ulid.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/ulid/1.0.0/ulid.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,IAAI,CAAC,QAAQ,GAAE,MAAmB,GAAG,MAAM,CAE1D"}

package/esm/deps/jsr.io/@std/ulid/1.0.0/ulid.js

@@ -0,0 +1,37 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright 2023 Yoshiya Hinosawa. All rights reserved. MIT license.
+// Copyright 2017 Alizain Feerasta. All rights reserved. MIT license.
+// This module is browser compatible.
+import { encodeRandom, encodeTime } from "./_util.js";
+/**
+ * Generate a ULID, optionally based on a given timestamp. If the timestamp is
+ * not passed, it will default to `Date.now()`.
+ *
+ * Multiple calls to this function with the same seed time will not guarantee
+ * that the ULIDs will be strictly increasing, even if the seed time is the
+ * same. For that, use the {@linkcode monotonicUlid} function.
+ *
+ * @example Generate a ULID
+ * ```ts no-assert
+ * import { ulid } from "@std/ulid";
+ *
+ * ulid(); // 01HYFKMDF3HVJ4J3JZW8KXPVTY
+ * ulid(); // 01HYFKMDF3D2P7G502B9Z2VKV0
+ * ulid(); // 01HYFKMDZQ7JD17CRKDXQSZ3Z4
+ * ```
+ *
+ * @example Generate a ULID with a seed time
+ * ```ts no-assert
+ * import { ulid } from "@std/ulid";
+ *
+ * ulid(150000); // 0000004JFG3EKDRE04TVVDJW7K
+ * ulid(150000); // 0000004JFGN0KHBH0447AK895X
+ * ulid(150000); // 0000004JFGMRDH0PN7SM8BZN06
+ * ```
+ *
+ * @param seedTime The time to base the ULID on, in milliseconds since the Unix epoch. Defaults to `Date.now()`.
+ * @returns A ULID.
+ */
+export function ulid(seedTime = Date.now()) {
+    return encodeTime(seedTime) + encodeRandom();
+}

package/esm/src/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/src/config.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAqB,MAAM,kBAAkB,CAAC;AAkB1E,KAAK,gBAAgB,GAAG;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAAC;AAEnD,KAAK,mBAAmB,GACpB,uBAAuB,GACvB,yBAAyB,GACzB,kBAAkB,GAClB,gBAAgB,CAAC;AAErB,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;gBAGjC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,mBAAmB,CAAA;KAAE;CAc1D;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAAC;IACxC,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAAC;CAC1C;AAED,KAAK,qBAAqB,GAAG,MAAM,qBAAqB,CAAC;AAsLzD,eAAO,MAAM,kCAAkC,GAC7C,SAAS,qBAAqB,KAC7B,IAEF,CAAC;AAEF,eAAO,MAAM,oCAAoC,QAAO,IAEvD,CAAC;AA2EF,wBAAgB,UAAU,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,cAAc,CAiB7D"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/src/config.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAqB,MAAM,kBAAkB,CAAC;AAkB1E,KAAK,gBAAgB,GAAG;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAAC;AAEnD,KAAK,mBAAmB,GACpB,uBAAuB,GACvB,yBAAyB,GACzB,kBAAkB,GAClB,gBAAgB,CAAC;AAErB,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;gBAGjC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,mBAAmB,CAAA;KAAE;CAiB1D;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAAC;IACxC,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAAC;CAC1C;AAED,KAAK,qBAAqB,GAAG,MAAM,qBAAqB,CAAC;AAuPzD,eAAO,MAAM,kCAAkC,GAC7C,SAAS,qBAAqB,KAC7B,IAEF,CAAC;AAEF,eAAO,MAAM,oCAAoC,QAAO,IAEvD,CAAC;AA6EF,wBAAgB,UAAU,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,cAAc,CAgB7D"}