vibe64 0.1.21

package/node_modules/@jskit-ai/kernel/server/http/lib/router.js

@@ -0,0 +1,239 @@
+import { ensureNonEmptyText, normalizeObject, normalizeText } from "../../../shared/support/normalize.js";
+import { RouteDefinitionError } from "./errors.js";
+import { resolveRouteValidatorOptions } from "./routeValidator.js";
+import { normalizeMiddlewareStack as normalizeSharedMiddlewareStack } from "./routeSupport.js";
+import { normalizeRouteOutputTransform, normalizeRouteTransport } from "./routeTransport.js";
+
+function normalizeMethod(method) {
+  return ensureNonEmptyText(method, "route method").toUpperCase();
+}
+
+function normalizePath(pathname) {
+  const value = normalizeText(pathname);
+  if (!value.startsWith("/")) {
+    throw new RouteDefinitionError(`Route path must start with '/': ${value || "<empty>"}`);
+  }
+  return value.replace(/\/+/g, "/");
+}
+
+function joinPath(left, right) {
+  const leftPath = normalizeText(left);
+  const rightPath = normalizeText(right);
+
+  const normalizedLeft = leftPath ? `/${leftPath.replace(/^\/+|\/+$/g, "")}` : "";
+  const normalizedRight = rightPath ? `/${rightPath.replace(/^\/+|\/+$/g, "")}` : "";
+  const joined = `${normalizedLeft}${normalizedRight}`.replace(/\/+/g, "/");
+  return joined || "/";
+}
+
+function normalizeRouterMiddlewareStack(value, { context = "middleware" } = {}) {
+  return normalizeSharedMiddlewareStack(value, {
+    context,
+    ErrorType: RouteDefinitionError,
+    entryLabel: "entries",
+    includeIndex: false
+  });
+}
+
+function normalizeRouteInternal(value, { method = "", path = "" } = {}) {
+  if (value == null) {
+    return false;
+  }
+  if (typeof value !== "boolean") {
+    throw new RouteDefinitionError(
+      `Route ${String(method || "<unknown>")} ${String(path || "<unknown>")} internal must be a boolean.`
+    );
+  }
+  return value;
+}
+
+function normalizeRouteInput(method, path, optionsOrHandler, maybeHandler) {
+  const options =
+    typeof optionsOrHandler === "function"
+      ? {}
+      : normalizeObject(optionsOrHandler, {
+          fallback: {}
+        });
+  const handler =
+    typeof optionsOrHandler === "function"
+      ? optionsOrHandler
+      : typeof maybeHandler === "function"
+        ? maybeHandler
+        : null;
+
+  if (typeof handler !== "function") {
+    throw new RouteDefinitionError(`Route ${method} ${path} requires a handler function.`);
+  }
+
+  return {
+    method: normalizeMethod(method),
+    path: normalizePath(path),
+    options,
+    handler
+  };
+}
+
+class HttpRouter {
+  constructor({ routes = null, prefix = "", middleware = [] } = {}) {
+    this._routes = Array.isArray(routes) ? routes : [];
+    this._prefix = normalizeText(prefix);
+    this._middleware = normalizeRouterMiddlewareStack(middleware, {
+      context: "router middleware"
+    });
+  }
+
+  register(method, path, optionsOrHandler, maybeHandler) {
+    const input = normalizeRouteInput(method, path, optionsOrHandler, maybeHandler);
+    const resolvedOptions = resolveRouteValidatorOptions({
+      method: input.method,
+      path: input.path,
+      options: input.options
+    });
+    const routeMiddleware = normalizeRouterMiddlewareStack(resolvedOptions.middleware, {
+      context: `Route ${input.method} ${input.path} middleware`
+    });
+    const routeInput = Object.hasOwn(resolvedOptions, "input") ? resolvedOptions.input : null;
+    const routeOutput = normalizeRouteOutputTransform(
+      Object.hasOwn(resolvedOptions, "output") ? resolvedOptions.output : null,
+      {
+        context: `Route ${input.method} ${input.path} output`,
+        ErrorType: RouteDefinitionError
+      }
+    );
+    const routeTransport = normalizeRouteTransport(
+      Object.hasOwn(resolvedOptions, "transport") ? resolvedOptions.transport : null,
+      {
+        context: `Route ${input.method} ${input.path} transport`,
+        ErrorType: RouteDefinitionError
+      }
+    );
+
+    const route = Object.freeze({
+      id: normalizeText(resolvedOptions.id),
+      method: input.method,
+      path: joinPath(this._prefix, input.path),
+      schema: resolvedOptions.schema,
+      input: routeInput,
+      output: routeOutput,
+      transport: routeTransport,
+      config: normalizeObject(resolvedOptions.config),
+      auth: resolvedOptions.auth,
+      contextPolicy: resolvedOptions.contextPolicy,
+      surface: resolvedOptions.surface,
+      internal: normalizeRouteInternal(resolvedOptions.internal, {
+        method: input.method,
+        path: input.path
+      }),
+      visibility: resolvedOptions.visibility,
+      permission: resolvedOptions.permission,
+      ownerParam: resolvedOptions.ownerParam,
+      userField: resolvedOptions.userField,
+      ownerResolver: resolvedOptions.ownerResolver,
+      csrfProtection: resolvedOptions.csrfProtection,
+      bodyLimit: resolvedOptions.bodyLimit,
+      middleware: Object.freeze([...this._middleware, ...routeMiddleware]),
+      handler: input.handler
+    });
+
+    this._routes.push(route);
+    return this;
+  }
+
+  get(path, optionsOrHandler, maybeHandler) {
+    return this.register("GET", path, optionsOrHandler, maybeHandler);
+  }
+
+  post(path, optionsOrHandler, maybeHandler) {
+    return this.register("POST", path, optionsOrHandler, maybeHandler);
+  }
+
+  put(path, optionsOrHandler, maybeHandler) {
+    return this.register("PUT", path, optionsOrHandler, maybeHandler);
+  }
+
+  patch(path, optionsOrHandler, maybeHandler) {
+    return this.register("PATCH", path, optionsOrHandler, maybeHandler);
+  }
+
+  delete(path, optionsOrHandler, maybeHandler) {
+    return this.register("DELETE", path, optionsOrHandler, maybeHandler);
+  }
+
+  group({ prefix = "", middleware = [] } = {}, defineRoutes = null) {
+    if (typeof defineRoutes !== "function") {
+      throw new RouteDefinitionError("group() requires a callback.");
+    }
+
+    const nestedRouter = new HttpRouter({
+      routes: this._routes,
+      prefix: joinPath(this._prefix, prefix || ""),
+      middleware: [
+        ...this._middleware,
+        ...normalizeRouterMiddlewareStack(middleware, {
+          context: "group middleware"
+        })
+      ]
+    });
+
+    defineRoutes(nestedRouter);
+    return this;
+  }
+
+  resource(name, controller, options = {}) {
+    this._resource(name, controller, {
+      ...normalizeObject(options),
+      apiOnly: false
+    });
+    return this;
+  }
+
+  apiResource(name, controller, options = {}) {
+    this._resource(name, controller, {
+      ...normalizeObject(options),
+      apiOnly: true
+    });
+    return this;
+  }
+
+  _resource(name, controller, options = {}) {
+    const resourceName = ensureNonEmptyText(name, "resource name");
+    const idParam = normalizeText(options.idParam, { fallback: "id" });
+    const basePath = `/${resourceName}`;
+    const itemPath = `/${resourceName}/:${idParam}`;
+
+    const methods = normalizeObject(controller);
+    const routeOptions = {
+      ...normalizeObject(options)
+    };
+    delete routeOptions.idParam;
+    delete routeOptions.apiOnly;
+
+    const requireMethod = (methodName) => {
+      const handler = methods[methodName];
+      if (typeof handler !== "function") {
+        throw new RouteDefinitionError(`resource controller for ${resourceName} is missing method ${methodName}().`);
+      }
+      return handler;
+    };
+
+    this.get(basePath, routeOptions, requireMethod("index"));
+    if (!options.apiOnly) {
+      this.get(`${basePath}/create`, routeOptions, requireMethod("create"));
+      this.get(`${itemPath}/edit`, routeOptions, requireMethod("edit"));
+    }
+    this.post(basePath, routeOptions, requireMethod("store"));
+    this.get(itemPath, routeOptions, requireMethod("show"));
+    this.put(itemPath, routeOptions, requireMethod("update"));
+    this.delete(itemPath, routeOptions, requireMethod("destroy"));
+  }
+
+  list() {
+    return Object.freeze([...this._routes]);
+  }
+}
+
+function createRouter(options = {}) {
+  return new HttpRouter(options);
+}
+
+export { HttpRouter, createRouter, joinPath };

package/node_modules/@jskit-ai/kernel/server/kernel/KernelCoreServiceProvider.js

@@ -0,0 +1,27 @@
+import { Application, createApplication, createProviderClass } from "../../shared/runtime/application.js";
+import { ServiceProvider } from "../../shared/runtime/serviceProvider.js";
+import * as errors from "../../shared/runtime/kernelErrors.js";
+
+const KERNEL_CORE_API = Object.freeze({
+  Application,
+  createApplication,
+  createProviderClass,
+  ServiceProvider,
+  errors: Object.freeze({ ...errors })
+});
+
+class KernelCoreServiceProvider {
+  static id = "runtime.kernel";
+
+  register(app) {
+    if (!app || typeof app.singleton !== "function") {
+      throw new Error("KernelCoreServiceProvider requires application singleton().");
+    }
+
+    app.singleton("runtime.kernel", () => KERNEL_CORE_API);
+  }
+
+  boot() {}
+}
+
+export { KernelCoreServiceProvider };

package/node_modules/@jskit-ai/kernel/server/kernel/index.js

@@ -0,0 +1,10 @@
+export { Application, createApplication, createProviderClass } from "../../shared/runtime/application.js";
+export { ServiceProvider } from "../../shared/runtime/serviceProvider.js";
+export {
+  KernelError,
+  ProviderNormalizationError,
+  DuplicateProviderError,
+  ProviderDependencyError,
+  ProviderLifecycleError
+} from "../../shared/runtime/kernelErrors.js";
+export { KernelCoreServiceProvider } from "./KernelCoreServiceProvider.js";

package/node_modules/@jskit-ai/kernel/server/platform/PlatformServerRuntimeServiceProvider.js

@@ -0,0 +1,30 @@
+import { createProviderRuntimeApp, createProviderRuntimeFromApp } from "./providerRuntime.js";
+import {
+  createPlatformRuntimeBundle,
+  createServerRuntime,
+  createServerRuntimeWithPlatformBundle
+} from "./runtime.js";
+
+const PLATFORM_SERVER_RUNTIME_API = Object.freeze({
+  createPlatformRuntimeBundle,
+  createServerRuntime,
+  createServerRuntimeWithPlatformBundle,
+  createProviderRuntimeApp,
+  createProviderRuntimeFromApp
+});
+
+class PlatformServerRuntimeServiceProvider {
+  static id = "runtime.platform-server";
+
+  register(app) {
+    if (!app || typeof app.singleton !== "function") {
+      throw new Error("PlatformServerRuntimeServiceProvider requires application singleton().");
+    }
+
+    app.singleton("runtime.platform-server", () => PLATFORM_SERVER_RUNTIME_API);
+  }
+
+  boot() {}
+}
+
+export { PlatformServerRuntimeServiceProvider };

package/node_modules/@jskit-ai/kernel/server/platform/index.js

@@ -0,0 +1,5 @@
+export {
+  registerSurfaceRequestConstraint,
+  resolveRuntimeProfileFromSurface,
+  tryCreateProviderRuntimeFromApp
+} from "./surfaceRuntime.js";

package/node_modules/@jskit-ai/kernel/server/platform/providerRuntime/descriptorCatalog.js

@@ -0,0 +1,170 @@
+import path from "node:path";
+import { sortStrings } from "../../../shared/support/sorting.js";
+import { loadInstalledPackageDescriptor } from "../../../internal/node/installedPackageDescriptor.js";
+
+function normalizeUiRoutePath(pathValue) {
+  const rawPath = String(pathValue || "").trim();
+  if (!rawPath || !rawPath.startsWith("/") || rawPath.startsWith("//")) {
+    return "";
+  }
+
+  const normalizedPath = rawPath.replace(/\/{2,}/g, "/");
+  if (normalizedPath === "/") {
+    return "/";
+  }
+
+  return normalizedPath.replace(/\/+$/, "") || "/";
+}
+
+function collectGlobalUiPaths(descriptorEntries) {
+  const globalUiPaths = [];
+  const entries = Array.isArray(descriptorEntries) ? descriptorEntries : [];
+
+  for (const descriptorEntry of entries) {
+    const uiRoutes = Array.isArray(descriptorEntry?.descriptor?.metadata?.ui?.routes)
+      ? descriptorEntry.descriptor.metadata.ui.routes
+      : [];
+
+    for (const routeEntry of uiRoutes) {
+      const routeRecord = routeEntry && typeof routeEntry === "object" && !Array.isArray(routeEntry) ? routeEntry : null;
+      if (!routeRecord) {
+        continue;
+      }
+
+      const scope = String(routeRecord.scope || "")
+        .trim()
+        .toLowerCase();
+      if (scope !== "global") {
+        continue;
+      }
+
+      const routePath = normalizeUiRoutePath(routeRecord.path);
+      if (!routePath) {
+        continue;
+      }
+      globalUiPaths.push(routePath);
+    }
+  }
+
+  return Object.freeze(sortStrings(globalUiPaths));
+}
+
+async function resolveInstalledPackageDescriptors({ appRoot, lock }) {
+  const installedPackages =
+    lock && typeof lock === "object" && lock.installedPackages && typeof lock.installedPackages === "object"
+      ? lock.installedPackages
+      : {};
+
+  const descriptorEntries = [];
+  for (const packageId of sortStrings(Object.keys(installedPackages))) {
+    const installedPackageState = installedPackages[packageId] || {};
+    const descriptorRecord = await loadInstalledPackageDescriptor({
+      appRoot,
+      installedPackageState,
+      packageId,
+      required: true
+    });
+    descriptorEntries.push({
+      packageId,
+      descriptor: descriptorRecord.descriptor,
+      descriptorPath: descriptorRecord.descriptorPath,
+      packageRoot: path.dirname(descriptorRecord.descriptorPath)
+    });
+  }
+
+  return descriptorEntries;
+}
+
+function resolveDescriptorLoadOrder(descriptorEntries) {
+  const byPackageId = new Map(descriptorEntries.map((entry) => [entry.packageId, entry]));
+  const visiting = new Set();
+  const visited = new Set();
+  const ordered = [];
+
+  function visit(packageId, lineage = []) {
+    if (visited.has(packageId)) {
+      return;
+    }
+    if (visiting.has(packageId)) {
+      throw new Error(`Package dependency cycle detected: ${[...lineage, packageId].join(" -> ")}`);
+    }
+
+    const entry = byPackageId.get(packageId);
+    if (!entry) {
+      return;
+    }
+
+    visiting.add(packageId);
+    const dependsOn = Array.isArray(entry.descriptor?.dependsOn) ? entry.descriptor.dependsOn : [];
+    for (const dependencyPackageId of dependsOn) {
+      if (byPackageId.has(dependencyPackageId)) {
+        visit(dependencyPackageId, [...lineage, packageId]);
+      }
+    }
+    visiting.delete(packageId);
+    visited.add(packageId);
+    ordered.push(entry);
+  }
+
+  for (const packageId of sortStrings([...byPackageId.keys()])) {
+    visit(packageId);
+  }
+
+  return ordered;
+}
+
+function registerCapabilityProvider(providersByCapability, capabilityId, providerPackageId) {
+  const normalizedCapabilityId = String(capabilityId || "").trim();
+  const normalizedProviderPackageId = String(providerPackageId || "").trim();
+  if (!normalizedCapabilityId || !normalizedProviderPackageId) {
+    return;
+  }
+
+  if (!providersByCapability.has(normalizedCapabilityId)) {
+    providersByCapability.set(normalizedCapabilityId, new Set());
+  }
+  providersByCapability.get(normalizedCapabilityId).add(normalizedProviderPackageId);
+}
+
+function validateDescriptorCapabilities(descriptorEntries, { builtinProvidersByCapability = {} } = {}) {
+  const providersByCapability = new Map();
+  for (const descriptorEntry of descriptorEntries) {
+    for (const capabilityId of Array.isArray(descriptorEntry.descriptor?.capabilities?.provides)
+      ? descriptorEntry.descriptor.capabilities.provides
+      : []) {
+      registerCapabilityProvider(providersByCapability, capabilityId, descriptorEntry.packageId);
+    }
+  }
+
+  for (const [capabilityId, providerPackageIds] of Object.entries(
+    builtinProvidersByCapability && typeof builtinProvidersByCapability === "object" ? builtinProvidersByCapability : {}
+  )) {
+    for (const providerPackageId of Array.isArray(providerPackageIds) ? providerPackageIds : [providerPackageIds]) {
+      registerCapabilityProvider(providersByCapability, capabilityId, providerPackageId);
+    }
+  }
+
+  for (const descriptorEntry of descriptorEntries) {
+    for (const capabilityId of Array.isArray(descriptorEntry.descriptor?.capabilities?.requires)
+      ? descriptorEntry.descriptor.capabilities.requires
+      : []) {
+      const normalizedCapabilityId = String(capabilityId || "").trim();
+      if (!normalizedCapabilityId) {
+        continue;
+      }
+      const providers = providersByCapability.get(normalizedCapabilityId);
+      if (!providers || providers.size < 1) {
+        throw new Error(
+          `Package ${descriptorEntry.packageId} requires capability ${normalizedCapabilityId}, but no installed package provides it.`
+        );
+      }
+    }
+  }
+}
+
+export {
+  collectGlobalUiPaths,
+  resolveInstalledPackageDescriptors,
+  resolveDescriptorLoadOrder,
+  validateDescriptorCapabilities
+};

package/node_modules/@jskit-ai/kernel/server/platform/providerRuntime/helpers.js

@@ -0,0 +1,45 @@
+import path from "node:path";
+import { escapeRegExp } from "../../../shared/surface/escapeRegExp.js";
+import { fileExists } from "../../../internal/node/fileSystem.js";
+
+function isIdentifier(value) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(String(value || ""));
+}
+
+function createWildcardMatcher(pattern) {
+  const rawPattern = String(pattern || "").trim();
+  if (!rawPattern) {
+    return null;
+  }
+
+  const escapedPattern = escapeRegExp(rawPattern).replace(/\\\*/g, ".*");
+  return new RegExp(`^${escapedPattern}$`);
+}
+
+function normalizeRelativePath(fromPath, targetPath) {
+  const relative = path.relative(path.resolve(fromPath), path.resolve(targetPath));
+  return relative.split(path.sep).join("/");
+}
+
+function isInsidePackageRoot(packageRoot, candidatePath) {
+  const relative = path.relative(path.resolve(packageRoot), path.resolve(candidatePath));
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function toAbsoluteSortedUniquePaths(values) {
+  const source = Array.isArray(values) ? values : [];
+  return Object.freeze(
+    [...new Set(source.map((entry) => path.resolve(entry)).filter(Boolean))].sort((left, right) =>
+      left.localeCompare(right)
+    )
+  );
+}
+
+export {
+  isIdentifier,
+  createWildcardMatcher,
+  normalizeRelativePath,
+  fileExists,
+  isInsidePackageRoot,
+  toAbsoluteSortedUniquePaths
+};

package/node_modules/@jskit-ai/kernel/server/platform/providerRuntime/lockfile.js

@@ -0,0 +1,27 @@
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { fileExists } from "../../../internal/node/fileSystem.js";
+
+async function readLockFromApp({ appRoot, lockPath = ".jskit/lock.json" } = {}) {
+  if (!appRoot || typeof appRoot !== "string") {
+    throw new TypeError("readLockFromApp requires appRoot.");
+  }
+
+  const absoluteLockPath = path.resolve(appRoot, String(lockPath || ".jskit/lock.json"));
+  if (!(await fileExists(absoluteLockPath))) {
+    throw new Error(`Lock file not found: ${absoluteLockPath}`);
+  }
+
+  const source = await readFile(absoluteLockPath, "utf8");
+  const lock = JSON.parse(source);
+  if (!lock || typeof lock !== "object") {
+    throw new TypeError(`Invalid lock file payload at ${absoluteLockPath}.`);
+  }
+
+  return {
+    lock,
+    lockPath: absoluteLockPath
+  };
+}
+
+export { readLockFromApp };