opencode-graphiti 0.2.0-canary.fdf8b85.20260323212818 → 0.2.0

package/README.md

@@ -145,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"]
@@ -155,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
 {
@@ -230,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

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;AAwLzD,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"}

package/esm/src/config.js

@@ -1,6 +1,7 @@
 import os from "node:os";
 import { createRequire } from "node:module";
 import { join } from "node:path";
+import { redactEndpointUserInfo } from "./services/endpoint-redaction.js";
 import { logger } from "./services/logger.js";
 const DEFAULT_CONFIG = {
     redis: {
@@ -29,6 +30,9 @@ export class ConfigLoadError extends Error {
         this.name = "ConfigLoadError";
         this.code = options.code;
         if (options.cause !== undefined) {
+            // dnt's Node-side type check still narrows Error to the legacy
+            // single-argument constructor here, so preserve standard cause semantics
+            // manually while keeping the generated build green.
             Object.defineProperty(this, "cause", {
                 value: options.cause,
                 writable: true,
@@ -77,30 +81,68 @@ const normalizeConfig = (value) => {
 const isPositiveInteger = (value) => typeof value === "number" && Number.isInteger(value) && value > 0;
 const isUnitInterval = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 &&
     value <= 1;
-const isValidUrlString = (value) => {
+const parseUrlString = (value) => {
     if (!value)
-        return false;
+        return null;
     try {
-        new URL(value);
-        return true;
+        return new URL(value);
     }
     catch {
-        return false;
+        return null;
     }
 };
-const assertExplicitUrl = (value, fieldName) => {
+const URL_SCHEME_PREFIX = /^[A-Za-z][A-Za-z\d+\-.]*:\/\//;
+const coerceConfiguredUrl = (value, fieldName, options) => {
     if (value === undefined)
-        return;
-    if (isValidUrlString(value))
-        return;
-    throw new ConfigLoadError(`Invalid Graphiti config value for ${fieldName}: expected a valid URL, received ${JSON.stringify(value)}`, { code: "config-invalid" });
+        return undefined;
+    const hasExplicitScheme = URL_SCHEME_PREFIX.test(value);
+    const candidate = hasExplicitScheme
+        ? value
+        : `${options.defaultScheme}://${value.replace(/^\/\//, "")}`;
+    const url = parseUrlString(candidate);
+    if (!url) {
+        throw new ConfigLoadError(`Invalid config value for ${fieldName}: expected a valid URL, received ${JSON.stringify(redactEndpointUserInfo(value))}`, { code: "config-invalid" });
+    }
+    if (!options.allowedSchemes ||
+        options.allowedSchemes.includes(url.protocol.slice(0, -1))) {
+        if (!hasExplicitScheme && options.defaultPort && !url.port) {
+            url.port = options.defaultPort;
+        }
+        return url.toString();
+    }
+    throw new ConfigLoadError(`Invalid config value for ${fieldName}: expected URL scheme ${options.allowedSchemes.map((scheme) => JSON.stringify(scheme)).join(" or ")}, received ${JSON.stringify(redactEndpointUserInfo(value))}`, { code: "config-invalid" });
 };
-const validateExplicitConfig = (value) => {
+const normalizeConfiguredEndpoints = (value) => {
     if (!value)
-        return;
-    assertExplicitUrl(value.endpoint, "endpoint");
-    assertExplicitUrl(value.graphiti?.endpoint, "graphiti.endpoint");
-    assertExplicitUrl(value.redis?.endpoint, "redis.endpoint");
+        return value;
+    return {
+        ...value,
+        endpoint: coerceConfiguredUrl(value.endpoint, "endpoint", {
+            allowedSchemes: ["http", "https"],
+            defaultScheme: "http",
+            defaultPort: "8000",
+        }),
+        graphiti: value.graphiti
+            ? {
+                ...value.graphiti,
+                endpoint: coerceConfiguredUrl(value.graphiti.endpoint, "graphiti.endpoint", {
+                    allowedSchemes: ["http", "https"],
+                    defaultScheme: "http",
+                    defaultPort: "8000",
+                }),
+            }
+            : value.graphiti,
+        redis: value.redis
+            ? {
+                ...value.redis,
+                endpoint: coerceConfiguredUrl(value.redis.endpoint, "redis.endpoint", {
+                    allowedSchemes: ["redis", "rediss"],
+                    defaultScheme: "redis",
+                    defaultPort: "6379",
+                }),
+            }
+            : value.redis,
+    };
 };
 const resolveNumber = (...candidates) => candidates.find((value) => value !== undefined);
 const resolveConfig = (value) => {
@@ -113,9 +155,8 @@ const resolveConfig = (value) => {
     const resolvedCacheTtlSeconds = resolveNumber(raw.redis?.cacheTtlSeconds);
     const resolvedDrainRetryMax = resolveNumber(raw.redis?.drainRetryMax);
     const requestedGraphitiEndpoint = raw.graphiti?.endpoint ?? raw.endpoint;
-    const resolvedGraphitiEndpoint = isValidUrlString(requestedGraphitiEndpoint)
-        ? requestedGraphitiEndpoint
-        : DEFAULT_CONFIG.graphiti.endpoint;
+    const resolvedGraphitiEndpoint = requestedGraphitiEndpoint ??
+        DEFAULT_CONFIG.graphiti.endpoint;
     const resolvedGroupIdPrefix = raw.graphiti?.groupIdPrefix ??
         raw.groupIdPrefix ??
         DEFAULT_CONFIG.graphiti.groupIdPrefix;
@@ -183,8 +224,9 @@ const getConfigExplorerAdapter = () => {
 const loadConfigFile = (adapter, filePath) => {
     try {
         const loaded = adapter?.load(filePath);
-        const normalized = loaded ? normalizeConfig(loaded.config) : null;
-        validateExplicitConfig(normalized);
+        const normalized = loaded
+            ? normalizeConfiguredEndpoints(normalizeConfig(loaded.config))
+            : null;
         return normalized;
     }
     catch (err) {
@@ -204,8 +246,9 @@ const getHomeDir = () => {
 const searchConfig = (adapter, directory) => {
     try {
         const loaded = adapter.search(directory);
-        const normalized = loaded ? normalizeConfig(loaded.config) : null;
-        validateExplicitConfig(normalized);
+        const normalized = loaded
+            ? normalizeConfiguredEndpoints(normalizeConfig(loaded.config))
+            : null;
         return normalized;
     }
     catch (err) {
@@ -232,7 +275,6 @@ export function loadConfig(directory) {
         const adapter = getConfigExplorerAdapter();
         const loaded = searchConfig(adapter, directory);
         const resolved = loaded ?? loadLegacyConfig(adapter);
-        validateExplicitConfig(resolved);
         return resolveConfig(resolved);
     }
     catch (error) {

package/esm/src/handlers/messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/src/handlers/messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAQjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,KAAK,qBAAqB,GAAG,WAAW,CACtC,KAAK,CAAC,sCAAsC,CAAC,CAC9C,CAAC;AAIF,MAAM,WAAW,mBAAmB;IAClC,cAAc,EAAE,cAAc,CAAC;CAChC;AAuCD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,mBAAmB,GACxB,qBAAqB,CAmEvB"}
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/src/handlers/messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAQjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,KAAK,qBAAqB,GAAG,WAAW,CACtC,KAAK,CAAC,sCAAsC,CAAC,CAC9C,CAAC;AAIF,MAAM,WAAW,mBAAmB;IAClC,cAAc,EAAE,cAAc,CAAC;CAChC;AAyFD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,mBAAmB,GACxB,qBAAqB,CAmEvB"}