@aopslabs/aops-server 0.2.9 → 0.2.11

package/build/server/chunks/chunks/exports.js-BoBrqMaZ.js

@@ -0,0 +1,215 @@
+import { n as noop, s as safe_not_equal } from './root.js-Di8SnzYO.js';
+
+const subscriber_queue = [];
+function readable(value, start) {
+  return {
+    subscribe: writable(value, start).subscribe
+  };
+}
+function writable(value, start = noop) {
+  let stop = null;
+  const subscribers = /* @__PURE__ */ new Set();
+  function set(new_value) {
+    if (safe_not_equal(value, new_value)) {
+      value = new_value;
+      if (stop) {
+        const run_queue = !subscriber_queue.length;
+        for (const subscriber of subscribers) {
+          subscriber[1]();
+          subscriber_queue.push(subscriber, value);
+        }
+        if (run_queue) {
+          for (let i = 0; i < subscriber_queue.length; i += 2) {
+            subscriber_queue[i][0](subscriber_queue[i + 1]);
+          }
+          subscriber_queue.length = 0;
+        }
+      }
+    }
+  }
+  function update(fn) {
+    set(fn(
+      /** @type {T} */
+      value
+    ));
+  }
+  function subscribe(run, invalidate = noop) {
+    const subscriber = [run, invalidate];
+    subscribers.add(subscriber);
+    if (subscribers.size === 1) {
+      stop = start(set, update) || noop;
+    }
+    run(
+      /** @type {T} */
+      value
+    );
+    return () => {
+      subscribers.delete(subscriber);
+      if (subscribers.size === 0 && stop) {
+        stop();
+        stop = null;
+      }
+    };
+  }
+  return { set, update, subscribe };
+}
+const internal = new URL("sveltekit-internal://");
+function resolve(base, path) {
+  if (path[0] === "/" && path[1] === "/") return path;
+  let url = new URL(base, internal);
+  url = new URL(path, url);
+  return url.protocol === internal.protocol ? url.pathname + url.search + url.hash : url.href;
+}
+function normalize_path(path, trailing_slash) {
+  if (path === "/" || trailing_slash === "ignore") return path;
+  if (trailing_slash === "never") {
+    return path.endsWith("/") ? path.slice(0, -1) : path;
+  } else if (trailing_slash === "always" && !path.endsWith("/")) {
+    return path + "/";
+  }
+  return path;
+}
+function decode_pathname(pathname) {
+  return pathname.split("%25").map(decodeURI).join("%25");
+}
+function decode_params(params) {
+  for (const key in params) {
+    params[key] = decodeURIComponent(params[key]);
+  }
+  return params;
+}
+function make_trackable(url, callback, search_params_callback, allow_hash = false) {
+  const tracked = new URL(url);
+  Object.defineProperty(tracked, "searchParams", {
+    value: new Proxy(tracked.searchParams, {
+      get(obj, key) {
+        if (key === "get" || key === "getAll" || key === "has") {
+          return (param, ...rest) => {
+            search_params_callback(param);
+            return obj[key](param, ...rest);
+          };
+        }
+        callback();
+        const value = Reflect.get(obj, key);
+        return typeof value === "function" ? value.bind(obj) : value;
+      }
+    }),
+    enumerable: true,
+    configurable: true
+  });
+  const tracked_url_properties = ["href", "pathname", "search", "toString", "toJSON"];
+  if (allow_hash) tracked_url_properties.push("hash");
+  for (const property of tracked_url_properties) {
+    Object.defineProperty(tracked, property, {
+      get() {
+        callback();
+        return url[property];
+      },
+      enumerable: true,
+      configurable: true
+    });
+  }
+  {
+    tracked[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+      return inspect(url, opts);
+    };
+    tracked.searchParams[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+      return inspect(url.searchParams, opts);
+    };
+  }
+  if (!allow_hash) {
+    disable_hash(tracked);
+  }
+  return tracked;
+}
+function disable_hash(url) {
+  allow_nodejs_console_log(url);
+  Object.defineProperty(url, "hash", {
+    get() {
+      throw new Error(
+        "Cannot access event.url.hash. Consider using `page.url.hash` inside a component instead"
+      );
+    }
+  });
+}
+function disable_search(url) {
+  allow_nodejs_console_log(url);
+  for (const property of ["search", "searchParams"]) {
+    Object.defineProperty(url, property, {
+      get() {
+        throw new Error(`Cannot access url.${property} on a page with prerendering enabled`);
+      }
+    });
+  }
+}
+function allow_nodejs_console_log(url) {
+  {
+    url[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+      return inspect(new URL(url), opts);
+    };
+  }
+}
+function validator(expected) {
+  function validate(module, file) {
+    if (!module) return;
+    for (const key in module) {
+      if (key[0] === "_" || expected.has(key)) continue;
+      const values = [...expected.values()];
+      const hint = hint_for_supported_files(key, file?.slice(file.lastIndexOf("."))) ?? `valid exports are ${values.join(", ")}, or anything with a '_' prefix`;
+      throw new Error(`Invalid export '${key}'${file ? ` in ${file}` : ""} (${hint})`);
+    }
+  }
+  return validate;
+}
+function hint_for_supported_files(key, ext = ".js") {
+  const supported_files = [];
+  if (valid_layout_exports.has(key)) {
+    supported_files.push(`+layout${ext}`);
+  }
+  if (valid_page_exports.has(key)) {
+    supported_files.push(`+page${ext}`);
+  }
+  if (valid_layout_server_exports.has(key)) {
+    supported_files.push(`+layout.server${ext}`);
+  }
+  if (valid_page_server_exports.has(key)) {
+    supported_files.push(`+page.server${ext}`);
+  }
+  if (valid_server_exports.has(key)) {
+    supported_files.push(`+server${ext}`);
+  }
+  if (supported_files.length > 0) {
+    return `'${key}' is a valid export in ${supported_files.slice(0, -1).join(", ")}${supported_files.length > 1 ? " or " : ""}${supported_files.at(-1)}`;
+  }
+}
+const valid_layout_exports = /* @__PURE__ */ new Set([
+  "load",
+  "prerender",
+  "csr",
+  "ssr",
+  "trailingSlash",
+  "config"
+]);
+const valid_page_exports = /* @__PURE__ */ new Set([...valid_layout_exports, "entries"]);
+const valid_layout_server_exports = /* @__PURE__ */ new Set([...valid_layout_exports]);
+const valid_page_server_exports = /* @__PURE__ */ new Set([...valid_layout_server_exports, "actions", "entries"]);
+const valid_server_exports = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PATCH",
+  "PUT",
+  "DELETE",
+  "OPTIONS",
+  "HEAD",
+  "fallback",
+  "prerender",
+  "trailingSlash",
+  "config",
+  "entries"
+]);
+const validate_layout_exports = validator(valid_layout_exports);
+const validate_page_exports = validator(valid_page_exports);
+const validate_layout_server_exports = validator(valid_layout_server_exports);
+const validate_page_server_exports = validator(valid_page_server_exports);
+
+export { disable_search as a, decode_params as b, validate_layout_exports as c, decode_pathname as d, validate_page_server_exports as e, validate_page_exports as f, readable as g, make_trackable as m, normalize_path as n, resolve as r, validate_layout_server_exports as v, writable as w };

package/build/server/chunks/chunks/internal.js-CQ9L-Epg.js

@@ -0,0 +1,126 @@
+import { r as root } from './root.js-Di8SnzYO.js';
+
+let read_implementation = null;
+function set_read_implementation(fn) {
+  read_implementation = fn;
+}
+let public_env = {};
+function set_private_env(environment) {
+}
+function set_public_env(environment) {
+  public_env = environment;
+}
+const error = ({ status, message }) => '<!doctype html>\n<html lang="en">\n	<head>\n		<meta charset="utf-8" />\n		<title>' + message + `</title>
+
+		<style>
+			body {
+				--bg: white;
+				--fg: #222;
+				--divider: #ccc;
+				background: var(--bg);
+				color: var(--fg);
+				font-family:
+					system-ui,
+					-apple-system,
+					BlinkMacSystemFont,
+					'Segoe UI',
+					Roboto,
+					Oxygen,
+					Ubuntu,
+					Cantarell,
+					'Open Sans',
+					'Helvetica Neue',
+					sans-serif;
+				display: flex;
+				align-items: center;
+				justify-content: center;
+				height: 100vh;
+				margin: 0;
+			}
+
+			.error {
+				display: flex;
+				align-items: center;
+				max-width: 32rem;
+				margin: 0 1rem;
+			}
+
+			.status {
+				font-weight: 200;
+				font-size: 3rem;
+				line-height: 1;
+				position: relative;
+				top: -0.05rem;
+			}
+
+			.message {
+				border-left: 1px solid var(--divider);
+				padding: 0 0 0 1rem;
+				margin: 0 0 0 1rem;
+				min-height: 2.5rem;
+				display: flex;
+				align-items: center;
+			}
+
+			.message h1 {
+				font-weight: 400;
+				font-size: 1em;
+				margin: 0;
+			}
+
+			@media (prefers-color-scheme: dark) {
+				body {
+					--bg: #222;
+					--fg: #ddd;
+					--divider: #666;
+				}
+			}
+		</style>
+	</head>
+	<body>
+		<div class="error">
+			<span class="status">` + status + '</span>\n			<div class="message">\n				<h1>' + message + "</h1>\n			</div>\n		</div>\n	</body>\n</html>\n";
+const options = {
+  app_template_contains_nonce: false,
+  async: false,
+  csp: { "mode": "auto", "directives": { "upgrade-insecure-requests": false, "block-all-mixed-content": false }, "reportOnly": { "upgrade-insecure-requests": false, "block-all-mixed-content": false } },
+  csrf_check_origin: true,
+  csrf_trusted_origins: [],
+  embedded: false,
+  env_public_prefix: "PUBLIC_",
+  env_private_prefix: "",
+  hash_routing: false,
+  hooks: null,
+  // added lazily, via `get_hooks`
+  preload_strategy: "modulepreload",
+  root,
+  service_worker: false,
+  service_worker_options: null,
+  server_error_boundaries: false,
+  templates: {
+    app: ({ head, body, assets, nonce, env }) => '<!doctype html>\n<html lang="en">\n  <head>\n    <meta charset="utf-8" />\n    <link rel="icon" href="' + assets + '/favicon.png" />\n    <meta name="viewport" content="width=device-width, initial-scale=1" />\n    ' + head + '\n  </head>\n  <body data-sveltekit-preload-data="hover">\n    <div style="display: contents">' + body + "</div>\n  </body>\n</html>\n",
+    error
+  },
+  version_hash: "dvnc2f"
+};
+async function get_hooks() {
+  let handle;
+  let handleFetch;
+  let handleError;
+  let handleValidationError;
+  let init;
+  ({ handle, handleFetch, handleError, handleValidationError, init } = await import('../entries/hooks.server.js-0eTKxvgl.js'));
+  let reroute;
+  let transport;
+  return {
+    handle,
+    handleFetch,
+    handleError,
+    handleValidationError,
+    init,
+    reroute,
+    transport
+  };
+}
+
+export { set_public_env as a, set_read_implementation as b, get_hooks as g, options as o, public_env as p, read_implementation as r, set_private_env as s };

package/build/server/chunks/chunks/json-request-body.js-ewKk-XAX.js

@@ -0,0 +1,18 @@
+import { isJsonHttpMediaType } from '@aopslabs/host-core';
+
+async function readJsonRequestBody(request, options = {}) {
+  if (!isJsonHttpMediaType(request.headers.get("content-type"))) {
+    return { ok: false, message: "application_json_content_type_required" };
+  }
+  const rawText = await request.text();
+  if (!rawText.trim()) {
+    return { ok: false, message: options.emptyBodyMessage ?? "request_body_required" };
+  }
+  try {
+    return { ok: true, value: JSON.parse(rawText) };
+  } catch {
+    return { ok: false, message: "invalid_json_body" };
+  }
+}
+
+export { readJsonRequestBody as r };

package/build/server/chunks/{registry-DIreA2IZ.js → chunks/registry.js-U3x77b7r.js}

@@ -2,13 +2,13 @@ import fs__default, { existsSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { createLeaseAdmissionProvider } from '@aopslabs/host-admission';
 import { createTrustedLocalAuthorityProvider } from '@aopslabs/host-auth';
 import { bootstrapHostRuntime, resolveHostConfig } from '@aopslabs/host-shell';
 import { Worker } from 'node:worker_threads';
 import { AdmissionDecisionCache, buildAdmittedDomainSnapshot, CommercialArtifactError } from '@aopslabs/artifact-trust-contracts';
-import './aops-runtime-config-CHpDUCdE.js';
+import './aops-runtime-config.js-CHpDUCdE.js';
 import { validateHostConfig } from '@aopslabs/host-core';
+import { createLeaseAdmissionProvider } from '@aopslabs/host-admission';
 
 const COMMUNITY_FREE_DOMAIN_IDS = Object.freeze([
   "agentspace",
@@ -83,7 +83,7 @@ function applyScheduledCommercialIntegrityFailure(error, now) {
 const configuredAdmission = process.env.AOPS_COMMERCIAL_ADMISSION_CONFIG?.trim();
 if (configuredAdmission) {
   try {
-    const { loadCommercialAdmissionSnapshot } = await import('./commercial-admission-loader-ZGZHRPLe.js');
+    const { loadCommercialAdmissionSnapshot } = await import('./commercial-admission-loader.js-ZGZHRPLe.js');
     const loaded = loadCommercialAdmissionSnapshot(
       configuredAdmission,
       COMMUNITY_FREE_DOMAIN_IDS
@@ -167,7 +167,7 @@ async function runScheduledIntegrityVerification() {
     dueAt: now.toISOString()
   });
   try {
-    const { resolveCommercialIntegrityWorkerInput } = await import('./commercial-admission-loader-ZGZHRPLe.js');
+    const { resolveCommercialIntegrityWorkerInput } = await import('./commercial-admission-loader.js-ZGZHRPLe.js');
     await runCommercialIntegrityVerificationWorker(
       resolveCommercialIntegrityWorkerInput(configuredAdmission),
       now
@@ -194,7 +194,7 @@ async function planScheduledIntegrityVerification() {
   if (!configuredAdmission || integrityWorkerRunning || integritySchedulerStopped) return;
   const now = /* @__PURE__ */ new Date();
   try {
-    const { readCommercialAdmissionIntegritySchedule } = await import('./commercial-admission-loader-ZGZHRPLe.js');
+    const { readCommercialAdmissionIntegritySchedule } = await import('./commercial-admission-loader.js-ZGZHRPLe.js');
     const schedule = readCommercialAdmissionIntegritySchedule(configuredAdmission, now);
     if (schedule.state === "authority-unavailable" || schedule.state === "quarantined") {
       applyScheduledCommercialIntegrityFailure(
@@ -395,6 +395,52 @@ function getHostRegistrationDiagnostics() {
     registrations: []
   };
 }
+function adaptTrustedLocalAdmissionProvider(source) {
+  return {
+    mode: source.mode,
+    async getSnapshot() {
+      const snapshot = await source.getSnapshot();
+      const domains = /* @__PURE__ */ new Map();
+      for (const [domainId, decision] of snapshot.domains) {
+        if (decision.plane === "customer" || decision.mode === "customer" || decision.customer) {
+          throw new Error(`aops_kernel_customer_admission_requires_south:${domainId}`);
+        }
+        domains.set(domainId, {
+          domain: decision.domain,
+          state: decision.state,
+          reason: decision.reason,
+          plane: decision.plane,
+          mode: decision.mode,
+          allowedOperationIds: decision.allowedOperationIds,
+          degradedOperationIds: decision.degradedOperationIds,
+          migrationEligible: decision.migrationEligible,
+          productId: decision.productId,
+          manifestDigest: decision.manifestDigest,
+          closureDigest: decision.closureDigest,
+          leaseId: decision.leaseId,
+          entitlementEpoch: decision.entitlementEpoch,
+          revocationEpoch: decision.revocationEpoch,
+          fullUntil: decision.fullUntil,
+          expiresAt: decision.expiresAt
+        });
+      }
+      return {
+        mode: snapshot.mode,
+        generation: snapshot.generation,
+        generatedAt: snapshot.generatedAt,
+        domains,
+        defaultDecision: snapshot.defaultDecision
+      };
+    }
+  };
+}
+function createTrustedLocalKernelAdmissionProvider(freeDomains) {
+  return adaptTrustedLocalAdmissionProvider(createLeaseAdmissionProvider({
+    generation: 1,
+    freeDomains,
+    licensedDomains: []
+  }));
+}
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const SERVER_PACKAGE_ROOT = [
   path.resolve(MODULE_DIR, "../.."),
@@ -444,11 +490,7 @@ function kernelBootstrapOptions() {
       roles: ["admin", "operator"],
       requireLoopback: false
     }),
-    admission: createLeaseAdmissionProvider({
-      generation: 1,
-      freeDomains: COMMUNITY_FREE_DOMAIN_IDS,
-      licensedDomains: []
-    })
+    admission: createTrustedLocalKernelAdmissionProvider(COMMUNITY_FREE_DOMAIN_IDS)
   };
 }
 async function warmupRuntime(runtime2) {
@@ -521,4 +563,4 @@ function resetHostPluginRegistry() {
   resetKernelRuntimeSnapshot();
 }
 
-export { getKernelRuntimeSnapshot as a, getHostRegistrationDiagnostics as b, getHostPluginRegistryDiagnostics as c, getHostAdmissionDiagnostics as d, getHostPluginRegistry as e, checkHostDomainAdmission as f, getHostConfig as g, resetHostPluginRegistry as h, resolveCommunityPackageModule as r };
+export { getKernelRuntimeSnapshot as a, getHostPluginRegistry as b, checkHostDomainAdmission as c, getHostRegistrationDiagnostics as d, getHostPluginRegistryDiagnostics as e, getHostAdmissionDiagnostics as f, getHostConfig as g, resolveCommunityPackageModule as h, resetHostPluginRegistry as r };

package/build/server/chunks/{request-context-9wzBoKrz.js → chunks/request-context.js-Y9Hk40z6.js}

@@ -1,9 +1,9 @@
-import { g as getResolvedAopsServerRuntimeConfig } from './aops-runtime-config-CHpDUCdE.js';
+import { g as getResolvedAopsServerRuntimeConfig } from './aops-runtime-config.js-CHpDUCdE.js';
 import { createAppMetaConfigManager } from '@aopslabs/xf-dm-kits/appConfig';
 import { getGlobalSingleton, cacheKeyFromLocale } from '@aopslabs/xf-dm-kits';
 import { createAgentspaceKitWithEnv } from '@aopslabs/domain-kit-agentspace';
-import { n as normalizeNonEmptyProjectText, r as resolveProjectAliasValue, g as getLogger } from './project-alias-BdnRxWft.js';
-import { e as errResult } from './xf-result-BRDjvftr.js';
+import { n as normalizeNonEmptyProjectText, r as resolveProjectAliasValue, g as getLogger } from './project-alias.js-BdnRxWft.js';
+import { e as errResult } from './xf-result.js-BRDjvftr.js';
 import { Effect } from 'effect';
 
 function resolveAgentspaceRepoUrl(_repositoryType) {