@ai-switch/tauri-plugin-runtime 0.1.0

package/dist/node/path.js

@@ -0,0 +1,434 @@
+import {
+  __commonJS,
+  __toESM
+} from "../chunk-JSBRDJBE.js";
+
+// ../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js
+var require_path_browserify = __commonJS({
+  "../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js"(exports, module) {
+    "use strict";
+    function assertPath(path) {
+      if (typeof path !== "string") {
+        throw new TypeError("Path must be a string. Received " + JSON.stringify(path));
+      }
+    }
+    function normalizeStringPosix(path, allowAboveRoot) {
+      var res = "";
+      var lastSegmentLength = 0;
+      var lastSlash = -1;
+      var dots = 0;
+      var code;
+      for (var i = 0; i <= path.length; ++i) {
+        if (i < path.length)
+          code = path.charCodeAt(i);
+        else if (code === 47)
+          break;
+        else
+          code = 47;
+        if (code === 47) {
+          if (lastSlash === i - 1 || dots === 1) {
+          } else if (lastSlash !== i - 1 && dots === 2) {
+            if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+              if (res.length > 2) {
+                var lastSlashIndex = res.lastIndexOf("/");
+                if (lastSlashIndex !== res.length - 1) {
+                  if (lastSlashIndex === -1) {
+                    res = "";
+                    lastSegmentLength = 0;
+                  } else {
+                    res = res.slice(0, lastSlashIndex);
+                    lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+                  }
+                  lastSlash = i;
+                  dots = 0;
+                  continue;
+                }
+              } else if (res.length === 2 || res.length === 1) {
+                res = "";
+                lastSegmentLength = 0;
+                lastSlash = i;
+                dots = 0;
+                continue;
+              }
+            }
+            if (allowAboveRoot) {
+              if (res.length > 0)
+                res += "/..";
+              else
+                res = "..";
+              lastSegmentLength = 2;
+            }
+          } else {
+            if (res.length > 0)
+              res += "/" + path.slice(lastSlash + 1, i);
+            else
+              res = path.slice(lastSlash + 1, i);
+            lastSegmentLength = i - lastSlash - 1;
+          }
+          lastSlash = i;
+          dots = 0;
+        } else if (code === 46 && dots !== -1) {
+          ++dots;
+        } else {
+          dots = -1;
+        }
+      }
+      return res;
+    }
+    function _format(sep, pathObject) {
+      var dir = pathObject.dir || pathObject.root;
+      var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+      if (!dir) {
+        return base;
+      }
+      if (dir === pathObject.root) {
+        return dir + base;
+      }
+      return dir + sep + base;
+    }
+    var posix2 = {
+      // path.resolve([from ...], to)
+      resolve: function resolve2() {
+        var resolvedPath = "";
+        var resolvedAbsolute = false;
+        var cwd;
+        for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+          var path;
+          if (i >= 0)
+            path = arguments[i];
+          else {
+            if (cwd === void 0)
+              cwd = process.cwd();
+            path = cwd;
+          }
+          assertPath(path);
+          if (path.length === 0) {
+            continue;
+          }
+          resolvedPath = path + "/" + resolvedPath;
+          resolvedAbsolute = path.charCodeAt(0) === 47;
+        }
+        resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+        if (resolvedAbsolute) {
+          if (resolvedPath.length > 0)
+            return "/" + resolvedPath;
+          else
+            return "/";
+        } else if (resolvedPath.length > 0) {
+          return resolvedPath;
+        } else {
+          return ".";
+        }
+      },
+      normalize: function normalize2(path) {
+        assertPath(path);
+        if (path.length === 0) return ".";
+        var isAbsolute2 = path.charCodeAt(0) === 47;
+        var trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+        path = normalizeStringPosix(path, !isAbsolute2);
+        if (path.length === 0 && !isAbsolute2) path = ".";
+        if (path.length > 0 && trailingSeparator) path += "/";
+        if (isAbsolute2) return "/" + path;
+        return path;
+      },
+      isAbsolute: function isAbsolute2(path) {
+        assertPath(path);
+        return path.length > 0 && path.charCodeAt(0) === 47;
+      },
+      join: function join2() {
+        if (arguments.length === 0)
+          return ".";
+        var joined;
+        for (var i = 0; i < arguments.length; ++i) {
+          var arg = arguments[i];
+          assertPath(arg);
+          if (arg.length > 0) {
+            if (joined === void 0)
+              joined = arg;
+            else
+              joined += "/" + arg;
+          }
+        }
+        if (joined === void 0)
+          return ".";
+        return posix2.normalize(joined);
+      },
+      relative: function relative2(from, to) {
+        assertPath(from);
+        assertPath(to);
+        if (from === to) return "";
+        from = posix2.resolve(from);
+        to = posix2.resolve(to);
+        if (from === to) return "";
+        var fromStart = 1;
+        for (; fromStart < from.length; ++fromStart) {
+          if (from.charCodeAt(fromStart) !== 47)
+            break;
+        }
+        var fromEnd = from.length;
+        var fromLen = fromEnd - fromStart;
+        var toStart = 1;
+        for (; toStart < to.length; ++toStart) {
+          if (to.charCodeAt(toStart) !== 47)
+            break;
+        }
+        var toEnd = to.length;
+        var toLen = toEnd - toStart;
+        var length = fromLen < toLen ? fromLen : toLen;
+        var lastCommonSep = -1;
+        var i = 0;
+        for (; i <= length; ++i) {
+          if (i === length) {
+            if (toLen > length) {
+              if (to.charCodeAt(toStart + i) === 47) {
+                return to.slice(toStart + i + 1);
+              } else if (i === 0) {
+                return to.slice(toStart + i);
+              }
+            } else if (fromLen > length) {
+              if (from.charCodeAt(fromStart + i) === 47) {
+                lastCommonSep = i;
+              } else if (i === 0) {
+                lastCommonSep = 0;
+              }
+            }
+            break;
+          }
+          var fromCode = from.charCodeAt(fromStart + i);
+          var toCode = to.charCodeAt(toStart + i);
+          if (fromCode !== toCode)
+            break;
+          else if (fromCode === 47)
+            lastCommonSep = i;
+        }
+        var out = "";
+        for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+          if (i === fromEnd || from.charCodeAt(i) === 47) {
+            if (out.length === 0)
+              out += "..";
+            else
+              out += "/..";
+          }
+        }
+        if (out.length > 0)
+          return out + to.slice(toStart + lastCommonSep);
+        else {
+          toStart += lastCommonSep;
+          if (to.charCodeAt(toStart) === 47)
+            ++toStart;
+          return to.slice(toStart);
+        }
+      },
+      _makeLong: function _makeLong(path) {
+        return path;
+      },
+      dirname: function dirname2(path) {
+        assertPath(path);
+        if (path.length === 0) return ".";
+        var code = path.charCodeAt(0);
+        var hasRoot = code === 47;
+        var end = -1;
+        var matchedSlash = true;
+        for (var i = path.length - 1; i >= 1; --i) {
+          code = path.charCodeAt(i);
+          if (code === 47) {
+            if (!matchedSlash) {
+              end = i;
+              break;
+            }
+          } else {
+            matchedSlash = false;
+          }
+        }
+        if (end === -1) return hasRoot ? "/" : ".";
+        if (hasRoot && end === 1) return "//";
+        return path.slice(0, end);
+      },
+      basename: function basename2(path, ext) {
+        if (ext !== void 0 && typeof ext !== "string") throw new TypeError('"ext" argument must be a string');
+        assertPath(path);
+        var start = 0;
+        var end = -1;
+        var matchedSlash = true;
+        var i;
+        if (ext !== void 0 && ext.length > 0 && ext.length <= path.length) {
+          if (ext.length === path.length && ext === path) return "";
+          var extIdx = ext.length - 1;
+          var firstNonSlashEnd = -1;
+          for (i = path.length - 1; i >= 0; --i) {
+            var code = path.charCodeAt(i);
+            if (code === 47) {
+              if (!matchedSlash) {
+                start = i + 1;
+                break;
+              }
+            } else {
+              if (firstNonSlashEnd === -1) {
+                matchedSlash = false;
+                firstNonSlashEnd = i + 1;
+              }
+              if (extIdx >= 0) {
+                if (code === ext.charCodeAt(extIdx)) {
+                  if (--extIdx === -1) {
+                    end = i;
+                  }
+                } else {
+                  extIdx = -1;
+                  end = firstNonSlashEnd;
+                }
+              }
+            }
+          }
+          if (start === end) end = firstNonSlashEnd;
+          else if (end === -1) end = path.length;
+          return path.slice(start, end);
+        } else {
+          for (i = path.length - 1; i >= 0; --i) {
+            if (path.charCodeAt(i) === 47) {
+              if (!matchedSlash) {
+                start = i + 1;
+                break;
+              }
+            } else if (end === -1) {
+              matchedSlash = false;
+              end = i + 1;
+            }
+          }
+          if (end === -1) return "";
+          return path.slice(start, end);
+        }
+      },
+      extname: function extname2(path) {
+        assertPath(path);
+        var startDot = -1;
+        var startPart = 0;
+        var end = -1;
+        var matchedSlash = true;
+        var preDotState = 0;
+        for (var i = path.length - 1; i >= 0; --i) {
+          var code = path.charCodeAt(i);
+          if (code === 47) {
+            if (!matchedSlash) {
+              startPart = i + 1;
+              break;
+            }
+            continue;
+          }
+          if (end === -1) {
+            matchedSlash = false;
+            end = i + 1;
+          }
+          if (code === 46) {
+            if (startDot === -1)
+              startDot = i;
+            else if (preDotState !== 1)
+              preDotState = 1;
+          } else if (startDot !== -1) {
+            preDotState = -1;
+          }
+        }
+        if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
+        preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
+        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+          return "";
+        }
+        return path.slice(startDot, end);
+      },
+      format: function format(pathObject) {
+        if (pathObject === null || typeof pathObject !== "object") {
+          throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+        }
+        return _format("/", pathObject);
+      },
+      parse: function parse(path) {
+        assertPath(path);
+        var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+        if (path.length === 0) return ret;
+        var code = path.charCodeAt(0);
+        var isAbsolute2 = code === 47;
+        var start;
+        if (isAbsolute2) {
+          ret.root = "/";
+          start = 1;
+        } else {
+          start = 0;
+        }
+        var startDot = -1;
+        var startPart = 0;
+        var end = -1;
+        var matchedSlash = true;
+        var i = path.length - 1;
+        var preDotState = 0;
+        for (; i >= start; --i) {
+          code = path.charCodeAt(i);
+          if (code === 47) {
+            if (!matchedSlash) {
+              startPart = i + 1;
+              break;
+            }
+            continue;
+          }
+          if (end === -1) {
+            matchedSlash = false;
+            end = i + 1;
+          }
+          if (code === 46) {
+            if (startDot === -1) startDot = i;
+            else if (preDotState !== 1) preDotState = 1;
+          } else if (startDot !== -1) {
+            preDotState = -1;
+          }
+        }
+        if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
+        preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
+        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+          if (end !== -1) {
+            if (startPart === 0 && isAbsolute2) ret.base = ret.name = path.slice(1, end);
+            else ret.base = ret.name = path.slice(startPart, end);
+          }
+        } else {
+          if (startPart === 0 && isAbsolute2) {
+            ret.name = path.slice(1, startDot);
+            ret.base = path.slice(1, end);
+          } else {
+            ret.name = path.slice(startPart, startDot);
+            ret.base = path.slice(startPart, end);
+          }
+          ret.ext = path.slice(startDot, end);
+        }
+        if (startPart > 0) ret.dir = path.slice(0, startPart - 1);
+        else if (isAbsolute2) ret.dir = "/";
+        return ret;
+      },
+      sep: "/",
+      delimiter: ":",
+      win32: null,
+      posix: null
+    };
+    posix2.posix = posix2;
+    module.exports = posix2;
+  }
+});
+
+// src/node/path.ts
+var import_path_browserify = __toESM(require_path_browserify(), 1);
+var join = (...parts) => import_path_browserify.default.join(...parts);
+var resolve = (...parts) => import_path_browserify.default.resolve("/data", ...parts);
+var normalize = (path) => import_path_browserify.default.normalize(path);
+var dirname = (path) => import_path_browserify.default.dirname(path);
+var basename = (path, suffix) => import_path_browserify.default.basename(path, suffix);
+var extname = (path) => import_path_browserify.default.extname(path);
+var isAbsolute = (path) => import_path_browserify.default.isAbsolute(path);
+var relative = (from, to) => import_path_browserify.default.relative(resolve(from), resolve(to));
+var path_default = Object.freeze({ join, resolve, normalize, dirname, basename, extname, relative, isAbsolute });
+export {
+  basename,
+  path_default as default,
+  dirname,
+  extname,
+  isAbsolute,
+  join,
+  normalize,
+  relative,
+  resolve
+};

package/dist/plugin/client.d.ts

@@ -0,0 +1,4 @@
+import type { SessionInfo } from "../protocol/wire.js";
+import type { RpcPeer } from "../bridge/rpc-types.js";
+import type { PluginApi } from "./types.js";
+export declare function createPluginClient(peer: RpcPeer, sessionInfo: SessionInfo): PluginApi;

package/dist/plugin/connection.d.ts

@@ -0,0 +1,6 @@
+import type { SessionInfo } from "../protocol/wire.js";
+import type { ConnectionState, PluginApi } from "./types.js";
+export declare function getPluginClient(): Promise<PluginApi>;
+export declare function connectPlugin(): Promise<SessionInfo>;
+export declare function supportsCapability(name: string, range?: string): boolean;
+export declare function onConnectionChange(callback: (state: ConnectionState) => void): () => void;

package/dist/plugin/errors.d.ts

@@ -0,0 +1,3 @@
+import { type ErrorPayload } from "../protocol/errors.js";
+/** The caller must already have validated the remote wire envelope. */
+export declare function fromErrorPayload(payload: ErrorPayload): Error;

package/dist/plugin/index.d.ts

@@ -0,0 +1,6 @@
+import { connectPlugin } from "./connection.js";
+import type { PluginApi } from "./types.js";
+export { connectPlugin };
+export type { CallOptions, ConnectionState, DirectorySelection, PluginApi } from "./types.js";
+/** Importing the public entry never connects or touches browser globals. */
+export declare const aplg: PluginApi;

package/dist/plugin/index.js

@@ -0,0 +1,12 @@
+import {
+  aplg,
+  connectPlugin
+} from "../chunk-K5YWIJN6.js";
+import "../chunk-PW7XHHWG.js";
+import "../chunk-RKQEK7DY.js";
+import "../chunk-WT62GTMC.js";
+import "../chunk-JSBRDJBE.js";
+export {
+  aplg,
+  connectPlugin
+};

package/dist/plugin/types.d.ts

@@ -0,0 +1,28 @@
+import type { CallOptions } from "../bridge/rpc-types.js";
+import type { SessionInfo, Unsubscribe } from "../protocol/wire.js";
+import type { JsonValue } from "../protocol/types.js";
+export type ConnectionState = "connected" | "disconnected" | "closed";
+export type DirectorySelection = {
+    path: string;
+    access: "read" | "readwrite";
+} | null;
+export interface PluginApi {
+    ready(): Promise<SessionInfo>;
+    capabilities: {
+        supports(name: string, range?: string): boolean;
+    };
+    call<T extends JsonValue>(capability: string, method: string, params?: JsonValue, options?: CallOptions): Promise<T>;
+    subscribe(capability: string, topic: string, handler: (payload: JsonValue) => void): Promise<Unsubscribe>;
+    onConnectionChange(handler: (state: ConnectionState) => void): Unsubscribe;
+    storage: {
+        get(key: string): Promise<JsonValue>;
+        set(key: string, value: JsonValue): Promise<void>;
+        remove(key: string): Promise<void>;
+    };
+    dialog: {
+        pickDirectory(options?: {
+            access?: "read" | "readwrite";
+        }): Promise<DirectorySelection>;
+    };
+}
+export type { CallOptions };

package/dist/protocol/capabilities.d.ts

@@ -0,0 +1,8 @@
+import type { JsonValue, ValidationResult } from "./types.js";
+/** Methods come from the authoritative schemas, not a second handwritten list. */
+export declare const standardCapabilities: Readonly<Record<string, {
+    readonly version: string;
+    readonly methods: readonly string[];
+}>>;
+export declare function validateCapabilityRequest(capability: string, method: string, params: unknown): ValidationResult<JsonValue>;
+export declare function validateCapabilityResult(capability: string, method: string, result: unknown): ValidationResult<JsonValue>;

package/dist/protocol/errors.d.ts

@@ -0,0 +1,14 @@
+import type { JsonValue } from "./types.js";
+import type { WireMessage } from "./generated/types.generated.js";
+export type ErrorPayload = Extract<WireMessage, {
+    kind: "error";
+}>["error"];
+export declare const errorCodes: readonly ["E_CAPABILITY_UNAVAILABLE", "E_PERMISSION_DENIED", "E_SESSION_CLOSED", "E_TIMEOUT", "E_CANCELLED", "E_LIMIT_EXCEEDED", "E_PROTOCOL_MISMATCH", "E_INVALID_ARGUMENT", "E_INVALID_MESSAGE", "E_HOST_UNAVAILABLE"];
+export type AplgErrorCode = typeof errorCodes[number];
+/** Only construct this with a deliberately public message and JSON details. */
+export declare class AplgError extends Error {
+    readonly code: AplgErrorCode;
+    readonly details?: JsonValue;
+    constructor(code: AplgErrorCode, message: string, details?: JsonValue);
+}
+export declare function toErrorPayload(error: unknown): ErrorPayload;

package/dist/protocol/generated/capabilities.generated.d.ts

@@ -0,0 +1,56 @@
+export type StandardCapabilityMessage = {
+    capability: "aplg.storage";
+    method: "get";
+    direction: "request";
+    value: {
+        key: string;
+    };
+} | {
+    capability: "aplg.storage";
+    method: "get";
+    direction: "result";
+    value: JsonValue;
+} | {
+    capability: "aplg.storage";
+    method: "set";
+    direction: "request";
+    value: {
+        key: string;
+        value: JsonValue;
+    };
+} | {
+    capability: "aplg.storage";
+    method: "set";
+    direction: "result";
+    value: null;
+} | {
+    capability: "aplg.storage";
+    method: "remove";
+    direction: "request";
+    value: {
+        key: string;
+    };
+} | {
+    capability: "aplg.storage";
+    method: "remove";
+    direction: "result";
+    value: null;
+} | {
+    capability: "aplg.dialog";
+    method: "pickDirectory";
+    direction: "request";
+    value: {
+        access?: "read" | "readwrite";
+    };
+} | {
+    capability: "aplg.dialog";
+    method: "pickDirectory";
+    direction: "result";
+    value: null | {
+        path: string;
+        access: "read" | "readwrite";
+    };
+};
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [k: string]: JsonValue;
+};