@cueframe/kernel 0.0.1

package/dist/TextureLoader-UQOFUSAP.js

@@ -0,0 +1,422 @@
+import {
+  Texture,
+  createElementNS
+} from "./chunk-JCZQT7K3.js";
+import "./chunk-2ESYSVXG.js";
+
+// ../../node_modules/.pnpm/three@0.183.2/node_modules/three/src/loaders/Cache.js
+var Cache = {
+  /**
+   * Whether caching is enabled or not.
+   *
+   * @static
+   * @type {boolean}
+   * @default false
+   */
+  enabled: false,
+  /**
+   * A dictionary that holds cached files.
+   *
+   * @static
+   * @type {Object<string,Object>}
+   */
+  files: {},
+  /**
+   * Adds a cache entry with a key to reference the file. If this key already
+   * holds a file, it is overwritten.
+   *
+   * @static
+   * @param {string} key - The key to reference the cached file.
+   * @param {Object} file -  The file to be cached.
+   */
+  add: function(key, file) {
+    if (this.enabled === false) return;
+    if (isBlobURL(key)) return;
+    this.files[key] = file;
+  },
+  /**
+   * Gets the cached value for the given key.
+   *
+   * @static
+   * @param {string} key - The key to reference the cached file.
+   * @return {Object|undefined} The cached file. If the key does not exist `undefined` is returned.
+   */
+  get: function(key) {
+    if (this.enabled === false) return;
+    if (isBlobURL(key)) return;
+    return this.files[key];
+  },
+  /**
+   * Removes the cached file associated with the given key.
+   *
+   * @static
+   * @param {string} key - The key to reference the cached file.
+   */
+  remove: function(key) {
+    delete this.files[key];
+  },
+  /**
+   * Remove all values from the cache.
+   *
+   * @static
+   */
+  clear: function() {
+    this.files = {};
+  }
+};
+function isBlobURL(key) {
+  try {
+    const urlString = key.slice(key.indexOf(":") + 1);
+    const url = new URL(urlString);
+    return url.protocol === "blob:";
+  } catch (e) {
+    return false;
+  }
+}
+
+// ../../node_modules/.pnpm/three@0.183.2/node_modules/three/src/loaders/LoadingManager.js
+var LoadingManager = class {
+  /**
+   * Constructs a new loading manager.
+   *
+   * @param {Function} [onLoad] - Executes when all items have been loaded.
+   * @param {Function} [onProgress] - Executes when single items have been loaded.
+   * @param {Function} [onError] - Executes when an error occurs.
+   */
+  constructor(onLoad, onProgress, onError) {
+    const scope = this;
+    let isLoading = false;
+    let itemsLoaded = 0;
+    let itemsTotal = 0;
+    let urlModifier = void 0;
+    const handlers = [];
+    this.onStart = void 0;
+    this.onLoad = onLoad;
+    this.onProgress = onProgress;
+    this.onError = onError;
+    this._abortController = null;
+    this.itemStart = function(url) {
+      itemsTotal++;
+      if (isLoading === false) {
+        if (scope.onStart !== void 0) {
+          scope.onStart(url, itemsLoaded, itemsTotal);
+        }
+      }
+      isLoading = true;
+    };
+    this.itemEnd = function(url) {
+      itemsLoaded++;
+      if (scope.onProgress !== void 0) {
+        scope.onProgress(url, itemsLoaded, itemsTotal);
+      }
+      if (itemsLoaded === itemsTotal) {
+        isLoading = false;
+        if (scope.onLoad !== void 0) {
+          scope.onLoad();
+        }
+      }
+    };
+    this.itemError = function(url) {
+      if (scope.onError !== void 0) {
+        scope.onError(url);
+      }
+    };
+    this.resolveURL = function(url) {
+      if (urlModifier) {
+        return urlModifier(url);
+      }
+      return url;
+    };
+    this.setURLModifier = function(transform) {
+      urlModifier = transform;
+      return this;
+    };
+    this.addHandler = function(regex, loader) {
+      handlers.push(regex, loader);
+      return this;
+    };
+    this.removeHandler = function(regex) {
+      const index = handlers.indexOf(regex);
+      if (index !== -1) {
+        handlers.splice(index, 2);
+      }
+      return this;
+    };
+    this.getHandler = function(file) {
+      for (let i = 0, l = handlers.length; i < l; i += 2) {
+        const regex = handlers[i];
+        const loader = handlers[i + 1];
+        if (regex.global) regex.lastIndex = 0;
+        if (regex.test(file)) {
+          return loader;
+        }
+      }
+      return null;
+    };
+    this.abort = function() {
+      this.abortController.abort();
+      this._abortController = null;
+      return this;
+    };
+  }
+  // TODO: Revert this back to a single member variable once this issue has been fixed
+  // https://github.com/cloudflare/workerd/issues/3657
+  /**
+   * Used for aborting ongoing requests in loaders using this manager.
+   *
+   * @type {AbortController}
+   */
+  get abortController() {
+    if (!this._abortController) {
+      this._abortController = new AbortController();
+    }
+    return this._abortController;
+  }
+};
+var DefaultLoadingManager = /* @__PURE__ */ new LoadingManager();
+
+// ../../node_modules/.pnpm/three@0.183.2/node_modules/three/src/loaders/Loader.js
+var Loader = class {
+  /**
+   * Constructs a new loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(manager) {
+    this.manager = manager !== void 0 ? manager : DefaultLoadingManager;
+    this.crossOrigin = "anonymous";
+    this.withCredentials = false;
+    this.path = "";
+    this.resourcePath = "";
+    this.requestHeader = {};
+    if (typeof __THREE_DEVTOOLS__ !== "undefined") {
+      __THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe", { detail: this }));
+    }
+  }
+  /**
+   * This method needs to be implemented by all concrete loaders. It holds the
+   * logic for loading assets from the backend.
+   *
+   * @abstract
+   * @param {string} url - The path/URL of the file to be loaded.
+   * @param {Function} onLoad - Executed when the loading process has been finished.
+   * @param {onProgressCallback} [onProgress] - Executed while the loading is in progress.
+   * @param {onErrorCallback} [onError] - Executed when errors occur.
+   */
+  load() {
+  }
+  /**
+   * A async version of {@link Loader#load}.
+   *
+   * @param {string} url - The path/URL of the file to be loaded.
+   * @param {onProgressCallback} [onProgress] - Executed while the loading is in progress.
+   * @return {Promise} A Promise that resolves when the asset has been loaded.
+   */
+  loadAsync(url, onProgress) {
+    const scope = this;
+    return new Promise(function(resolve, reject) {
+      scope.load(url, resolve, onProgress, reject);
+    });
+  }
+  /**
+   * This method needs to be implemented by all concrete loaders. It holds the
+   * logic for parsing the asset into three.js entities.
+   *
+   * @abstract
+   * @param {any} data - The data to parse.
+   */
+  parse() {
+  }
+  /**
+   * Sets the `crossOrigin` String to implement CORS for loading the URL
+   * from a different domain that allows CORS.
+   *
+   * @param {string} crossOrigin - The `crossOrigin` value.
+   * @return {Loader} A reference to this instance.
+   */
+  setCrossOrigin(crossOrigin) {
+    this.crossOrigin = crossOrigin;
+    return this;
+  }
+  /**
+   * Whether the XMLHttpRequest uses credentials such as cookies, authorization
+   * headers or TLS client certificates, see [XMLHttpRequest.withCredentials](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/withCredentials).
+   *
+   * Note: This setting has no effect if you are loading files locally or from the same domain.
+   *
+   * @param {boolean} value - The `withCredentials` value.
+   * @return {Loader} A reference to this instance.
+   */
+  setWithCredentials(value) {
+    this.withCredentials = value;
+    return this;
+  }
+  /**
+   * Sets the base path for the asset.
+   *
+   * @param {string} path - The base path.
+   * @return {Loader} A reference to this instance.
+   */
+  setPath(path) {
+    this.path = path;
+    return this;
+  }
+  /**
+   * Sets the base path for dependent resources like textures.
+   *
+   * @param {string} resourcePath - The resource path.
+   * @return {Loader} A reference to this instance.
+   */
+  setResourcePath(resourcePath) {
+    this.resourcePath = resourcePath;
+    return this;
+  }
+  /**
+   * Sets the given request header.
+   *
+   * @param {Object} requestHeader - A [request header](https://developer.mozilla.org/en-US/docs/Glossary/Request_header)
+   * for configuring the HTTP request.
+   * @return {Loader} A reference to this instance.
+   */
+  setRequestHeader(requestHeader) {
+    this.requestHeader = requestHeader;
+    return this;
+  }
+  /**
+   * This method can be implemented in loaders for aborting ongoing requests.
+   *
+   * @abstract
+   * @return {Loader} A reference to this instance.
+   */
+  abort() {
+    return this;
+  }
+};
+Loader.DEFAULT_MATERIAL_NAME = "__DEFAULT";
+
+// ../../node_modules/.pnpm/three@0.183.2/node_modules/three/src/loaders/ImageLoader.js
+var _loading = /* @__PURE__ */ new WeakMap();
+var ImageLoader = class extends Loader {
+  /**
+   * Constructs a new image loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(manager) {
+    super(manager);
+  }
+  /**
+   * Starts loading from the given URL and passes the loaded image
+   * to the `onLoad()` callback. The method also returns a new `Image` object which can
+   * directly be used for texture creation. If you do it this way, the texture
+   * may pop up in your scene once the respective loading process is finished.
+   *
+   * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
+   * @param {function(Image)} onLoad - Executed when the loading process has been finished.
+   * @param {onProgressCallback} onProgress - Unsupported in this loader.
+   * @param {onErrorCallback} onError - Executed when errors occur.
+   * @return {Image} The image.
+   */
+  load(url, onLoad, onProgress, onError) {
+    if (this.path !== void 0) url = this.path + url;
+    url = this.manager.resolveURL(url);
+    const scope = this;
+    const cached = Cache.get(`image:${url}`);
+    if (cached !== void 0) {
+      if (cached.complete === true) {
+        scope.manager.itemStart(url);
+        setTimeout(function() {
+          if (onLoad) onLoad(cached);
+          scope.manager.itemEnd(url);
+        }, 0);
+      } else {
+        let arr = _loading.get(cached);
+        if (arr === void 0) {
+          arr = [];
+          _loading.set(cached, arr);
+        }
+        arr.push({ onLoad, onError });
+      }
+      return cached;
+    }
+    const image = createElementNS("img");
+    function onImageLoad() {
+      removeEventListeners();
+      if (onLoad) onLoad(this);
+      const callbacks = _loading.get(this) || [];
+      for (let i = 0; i < callbacks.length; i++) {
+        const callback = callbacks[i];
+        if (callback.onLoad) callback.onLoad(this);
+      }
+      _loading.delete(this);
+      scope.manager.itemEnd(url);
+    }
+    function onImageError(event) {
+      removeEventListeners();
+      if (onError) onError(event);
+      Cache.remove(`image:${url}`);
+      const callbacks = _loading.get(this) || [];
+      for (let i = 0; i < callbacks.length; i++) {
+        const callback = callbacks[i];
+        if (callback.onError) callback.onError(event);
+      }
+      _loading.delete(this);
+      scope.manager.itemError(url);
+      scope.manager.itemEnd(url);
+    }
+    function removeEventListeners() {
+      image.removeEventListener("load", onImageLoad, false);
+      image.removeEventListener("error", onImageError, false);
+    }
+    image.addEventListener("load", onImageLoad, false);
+    image.addEventListener("error", onImageError, false);
+    if (url.slice(0, 5) !== "data:") {
+      if (this.crossOrigin !== void 0) image.crossOrigin = this.crossOrigin;
+    }
+    Cache.add(`image:${url}`, image);
+    scope.manager.itemStart(url);
+    image.src = url;
+    return image;
+  }
+};
+
+// ../../node_modules/.pnpm/three@0.183.2/node_modules/three/src/loaders/TextureLoader.js
+var TextureLoader = class extends Loader {
+  /**
+   * Constructs a new texture loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(manager) {
+    super(manager);
+  }
+  /**
+   * Starts loading from the given URL and pass the fully loaded texture
+   * to the `onLoad()` callback. The method also returns a new texture object which can
+   * directly be used for material creation. If you do it this way, the texture
+   * may pop up in your scene once the respective loading process is finished.
+   *
+   * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
+   * @param {function(Texture)} onLoad - Executed when the loading process has been finished.
+   * @param {onProgressCallback} onProgress - Unsupported in this loader.
+   * @param {onErrorCallback} onError - Executed when errors occur.
+   * @return {Texture} The texture.
+   */
+  load(url, onLoad, onProgress, onError) {
+    const texture = new Texture();
+    const loader = new ImageLoader(this.manager);
+    loader.setCrossOrigin(this.crossOrigin);
+    loader.setPath(this.path);
+    loader.load(url, function(image) {
+      texture.image = image;
+      texture.needsUpdate = true;
+      if (onLoad !== void 0) {
+        onLoad(texture);
+      }
+    }, onProgress, onError);
+    return texture;
+  }
+};
+export {
+  TextureLoader
+};

package/dist/VideoTexture-AQWSPIJG.js

@@ -0,0 +1,62 @@
+import {
+  LinearFilter,
+  Texture
+} from "./chunk-JCZQT7K3.js";
+import "./chunk-2ESYSVXG.js";
+
+// ../../node_modules/.pnpm/three@0.183.2/node_modules/three/src/textures/VideoTexture.js
+var VideoTexture = class extends Texture {
+  /**
+   * Constructs a new video texture.
+   *
+   * @param {HTMLVideoElement} video - The video element to use as a data source for the texture.
+   * @param {number} [mapping=Texture.DEFAULT_MAPPING] - The texture mapping.
+   * @param {number} [wrapS=ClampToEdgeWrapping] - The wrapS value.
+   * @param {number} [wrapT=ClampToEdgeWrapping] - The wrapT value.
+   * @param {number} [magFilter=LinearFilter] - The mag filter value.
+   * @param {number} [minFilter=LinearFilter] - The min filter value.
+   * @param {number} [format=RGBAFormat] - The texture format.
+   * @param {number} [type=UnsignedByteType] - The texture type.
+   * @param {number} [anisotropy=Texture.DEFAULT_ANISOTROPY] - The anisotropy value.
+   */
+  constructor(video, mapping, wrapS, wrapT, magFilter = LinearFilter, minFilter = LinearFilter, format, type, anisotropy) {
+    super(video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy);
+    this.isVideoTexture = true;
+    this.generateMipmaps = false;
+    this._requestVideoFrameCallbackId = 0;
+    const scope = this;
+    function updateVideo() {
+      scope.needsUpdate = true;
+      scope._requestVideoFrameCallbackId = video.requestVideoFrameCallback(updateVideo);
+    }
+    if ("requestVideoFrameCallback" in video) {
+      this._requestVideoFrameCallbackId = video.requestVideoFrameCallback(updateVideo);
+    }
+  }
+  clone() {
+    return new this.constructor(this.image).copy(this);
+  }
+  /**
+   * This method is called automatically by the renderer and sets {@link Texture#needsUpdate}
+   * to `true` every time a new frame is available.
+   *
+   * Only relevant if `requestVideoFrameCallback` is not supported in the browser.
+   */
+  update() {
+    const video = this.image;
+    const hasVideoFrameCallback = "requestVideoFrameCallback" in video;
+    if (hasVideoFrameCallback === false && video.readyState >= video.HAVE_CURRENT_DATA) {
+      this.needsUpdate = true;
+    }
+  }
+  dispose() {
+    if (this._requestVideoFrameCallbackId !== 0) {
+      this.source.data.cancelVideoFrameCallback(this._requestVideoFrameCallbackId);
+      this._requestVideoFrameCallbackId = 0;
+    }
+    super.dispose();
+  }
+};
+export {
+  VideoTexture
+};

package/dist/_members/account-model/index.d.ts

@@ -0,0 +1 @@
+export * from "./validators/index.js";

package/dist/_members/account-model/index.js

@@ -0,0 +1,4 @@
+// @cueframe/account-model — API-exposed account-domain shapes (user
+// preferences, conversation threads, upload tokens, context files,
+// dashboard insight cache).
+export * from "./validators/index.js";

package/dist/_members/account-model/testing/conversationStoreContract.d.ts

@@ -0,0 +1,97 @@
+/**
+ * THE CONVERSATION STORE CONTRACT — one executable statement, every store.
+ *
+ * A Director thread is persisted by TWO independent implementations: the
+ * desktop's sqlite (`cueframe/src-tauri/src/database/conversations.rs`) and the
+ * org's Convex documents (`the backend conversation store`), reached through
+ * an adapter each (`platform/tauri.ts`, `packages/web/adapter.ts`). A third
+ * "implementation" exists in the test double the app's own tests run against.
+ *
+ * THEY AGREED BY REVIEW DISCIPLINE, AND THAT FAILED. Three separate files
+ * carried prose saying both stores held the same rules. Two of those rules were
+ * true in one store only — the refusal to re-point a thread (Convex threw,
+ * sqlite silently accepted) and the immutability of a thread's creation time
+ * (Convex's `_creationTime`; sqlite's `INSERT OR REPLACE` rewrote it every
+ * turn). A third divergence was the live bug this whole effort started from:
+ * sqlite upserted on the app's id while Convex inserted a new document per
+ * turn, so one web conversation became N rows. Every one of those was invisible
+ * because each store was tested only against itself.
+ *
+ * This file is the fix: the facts as ASSERTIONS, parameterised over the store.
+ * A lane that wants to claim the contract runs it. There is no per-lane copy to
+ * drift, and a fact added here fails everywhere it is not yet true.
+ *
+ * WHY A PARAMETERISED SUITE AND NOT A DATA TABLE like `packages/plane`'s
+ * conformance rows: the plane's cases are STATELESS — the fixture travels in
+ * the request body, so a row is genuinely lane-agnostic data. Conversation
+ * storage is stateful CRUD over four verbs, where a fact reads "save this
+ * thrice, then list, then count". Encoding that as data needs an op-script
+ * schema plus an interpreter per lane; encoding it as a function needs neither.
+ *
+ * THESE ARE THE TWO MECHANISMS, and there are only two. `packages/plane/src/
+ * conformance.ts` holds stateless OPERATIONS both lanes serve; this shape holds
+ * stateful STORES behind one interface. CLAUDE.md carries the decision table —
+ * read it before inventing a third.
+ *
+ * WHY THE RUST LANE IS NOT DRIVEN FROM HERE: it lives behind `cargo test`, and
+ * reaching it from TypeScript means either a WebDriver stack (`tauri-driver`
+ * does not support macOS, the dev platform) or a codegen bridge — machinery
+ * several times the size of the 250 lines it would test. Instead the same facts
+ * are written as `#[tokio::test]`s in `database/mod.rs` UNDER THE SAME NAMES.
+ * Matching names are the seam: a fact that gains a test on one side and not the
+ * other is one grep away.
+ */
+/** The project a thread is about, as the store surface spells it. */
+export interface ContractProjectRef {
+    id: string;
+    home: "local" | "cloud";
+}
+export interface ContractConversationMeta {
+    id: string;
+    title: string;
+    project: ContractProjectRef | null;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface ContractConversation extends ContractConversationMeta {
+    messages: string;
+}
+/**
+ * The store surface under test — the conversation half of `DatabaseAdapter`.
+ * Each lane supplies a thin adapter onto its own implementation.
+ */
+export interface ConversationStoreUnderTest {
+    list(project: ContractProjectRef | null): Promise<ContractConversationMeta[]>;
+    get(id: string, project: ContractProjectRef | null): Promise<ContractConversation | null>;
+    save(conversation: ContractConversation): Promise<void>;
+    remove(id: string): Promise<void>;
+}
+/** Vitest's primitives, injected so this package needs no test-runner dependency. */
+export interface ContractHarness {
+    describe: (name: string, fn: () => void) => void;
+    it: ((name: string, fn: () => Promise<void> | void) => void) & {
+        fails: (name: string, fn: () => Promise<void> | void) => void;
+    };
+    expect: (actual: unknown) => {
+        toEqual: (expected: unknown) => void;
+        toBe: (expected: unknown) => void;
+        toBeNull: () => void;
+        toHaveLength: (n: number) => void;
+        rejects: {
+            toThrow: (matcher?: RegExp) => Promise<void>;
+        };
+    };
+    /** A fresh, EMPTY store for one fact. */
+    makeStore: () => Promise<ConversationStoreUnderTest> | ConversationStoreUnderTest;
+    /**
+     * Facts this lane does not hold yet, by name.
+     *
+     * Borrowed from `packages/plane/src/conformance.ts`: a named row becomes
+     * `it.fails`, which asserts the test does NOT pass — so the day the lane is
+     * fixed, this entry starts failing and whoever fixed it is forced to delete
+     * the marker. A skip would rot silently; this cannot. Use it to record a
+     * divergence, never to excuse one.
+     */
+    knownRed?: readonly string[];
+}
+export declare function describeConversationStoreContract(name: string, harness: ContractHarness): void;