@jskit-ai/kernel 0.1.244 → 0.1.246

package/shared/support/mobileConfig.test.js

@@ -0,0 +1,113 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { normalizeMobileCallbackPath, normalizeMobileConfig } from "./mobileConfig.js";
+
+test("normalizeMobileCallbackPath normalizes auth callback paths", () => {
+  assert.equal(normalizeMobileCallbackPath("auth/login"), "/auth/login");
+  assert.equal(normalizeMobileCallbackPath("/auth/login"), "/auth/login");
+  assert.equal(
+    normalizeMobileCallbackPath("", {
+      fallback: "/login/callback"
+    }),
+    "/login/callback"
+  );
+});
+
+test("normalizeMobileConfig normalizes the mobile config contract", () => {
+  const mobileConfig = normalizeMobileConfig({
+    enabled: true,
+    strategy: " Capacitor ",
+    appId: "com.example.convict",
+    appName: "Convict",
+    assetMode: " dev_server ",
+    devServerUrl: " http://192.168.1.10:5173 ",
+    apiBaseUrl: " https://api.example.com ",
+    auth: {
+      callbackPath: "auth/login",
+      customScheme: " Convict ",
+      appLinkDomains: ["App.Example.com", " app.example.com "]
+    },
+    android: {
+      packageName: "com.example.convict",
+      minSdk: "28",
+      targetSdk: "35",
+      versionCode: "4",
+      versionName: "2.0.0"
+    }
+  });
+
+  assert.deepEqual(mobileConfig, {
+    enabled: true,
+    strategy: "capacitor",
+    appId: "com.example.convict",
+    appName: "Convict",
+    assetMode: "dev_server",
+    devServerUrl: "http://192.168.1.10:5173",
+    apiBaseUrl: "https://api.example.com",
+    auth: {
+      callbackPath: "/auth/login",
+      customScheme: "convict",
+      appLinkDomains: ["app.example.com"]
+    },
+    android: {
+      packageName: "com.example.convict",
+      minSdk: 28,
+      targetSdk: 35,
+      versionCode: 4,
+      versionName: "2.0.0"
+    }
+  });
+});
+
+test("normalizeMobileConfig applies defaults for missing fields", () => {
+  const mobileConfig = normalizeMobileConfig({
+    auth: {
+      appLinkDomains: "app.example.com"
+    },
+    android: {
+      minSdk: "bad",
+      targetSdk: 0,
+      versionCode: "",
+      versionName: ""
+    }
+  });
+
+  assert.deepEqual(mobileConfig, {
+    enabled: false,
+    strategy: "",
+    appId: "",
+    appName: "",
+    assetMode: "bundled",
+    devServerUrl: "",
+    apiBaseUrl: "",
+    auth: {
+      callbackPath: "/auth/login",
+      customScheme: "",
+      appLinkDomains: ["app.example.com"]
+    },
+    android: {
+      packageName: "",
+      minSdk: 26,
+      targetSdk: 35,
+      versionCode: 1,
+      versionName: "1.0.0"
+    }
+  });
+});
+
+test("normalizeMobileConfig preserves explicit false values from string input", () => {
+  const mobileConfig = normalizeMobileConfig({
+    enabled: "false"
+  });
+
+  assert.equal(mobileConfig.enabled, false);
+});
+
+test("normalizeMobileConfig rejects invalid assetMode values", () => {
+  assert.throws(
+    () => normalizeMobileConfig({
+      assetMode: "weird"
+    }),
+    /config\.mobile\.assetMode must be "bundled" or "dev_server"\./u
+  );
+});

package/shared/support/normalize.js

@@ -134,20 +134,6 @@ function normalizeIfInSource(source, normalized, fieldName, normalizer = (value)
   return normalized;
 }
 
-function normalizeIfPresent(value, normalizer = (entry) => entry) {
-  if (typeof normalizer !== "function") {
-    throw new TypeError("normalizeIfPresent requires normalizer function.");
-  }
-  return value == null ? value : normalizer(value);
-}
-
-function normalizeOrNull(value, normalizer = (entry) => entry) {
-  if (typeof normalizer !== "function") {
-    throw new TypeError("normalizeOrNull requires normalizer function.");
-  }
-  return value == null ? null : normalizer(value);
-}
-
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -260,94 +246,6 @@ function normalizeOneOf(value, allowedValues = [], fallback = "") {
   return supported[0] || "";
 }
 
-const MOBILE_ASSET_MODES = Object.freeze(["bundled", "dev_server"]);
-const MOBILE_STRATEGIES = Object.freeze(["capacitor"]);
-const DEFAULT_MOBILE_AUTH_CONFIG = Object.freeze({
-  callbackPath: "/auth/login",
-  customScheme: "",
-  appLinkDomains: Object.freeze([])
-});
-const DEFAULT_MOBILE_ANDROID_CONFIG = Object.freeze({
-  packageName: "",
-  minSdk: 26,
-  targetSdk: 35,
-  versionCode: 1,
-  versionName: "1.0.0"
-});
-
-function normalizeMobileStrategy(value = "", { fallback = "" } = {}) {
-  const normalized = normalizeLowerText(value);
-  return MOBILE_STRATEGIES.includes(normalized) ? normalized : normalizeLowerText(fallback);
-}
-
-function normalizeMobileAssetMode(value = "", { fallback = "bundled" } = {}) {
-  const normalized = normalizeLowerText(value);
-  if (!normalized) {
-    return normalizeLowerText(fallback, {
-      fallback: "bundled"
-    });
-  }
-  if (!MOBILE_ASSET_MODES.includes(normalized)) {
-    throw new TypeError('config.mobile.assetMode must be "bundled" or "dev_server".');
-  }
-  return normalized;
-}
-
-function normalizeMobileCallbackPath(value = "", { fallback = "/auth/login" } = {}) {
-  const normalized = normalizeText(value, {
-    fallback
-  });
-  if (!normalized) {
-    return "";
-  }
-
-  return normalized.startsWith("/") ? normalized : `/${normalized}`;
-}
-
-function normalizeMobileConfig(source = {}) {
-  const mobile = normalizeObject(source);
-  const auth = normalizeObject(mobile.auth);
-  const android = normalizeObject(mobile.android);
-
-  return Object.freeze({
-    enabled: hasValue(mobile.enabled) ? normalizeBoolean(mobile.enabled) : false,
-    strategy: normalizeMobileStrategy(mobile.strategy),
-    appId: normalizeText(mobile.appId),
-    appName: normalizeText(mobile.appName),
-    assetMode: normalizeMobileAssetMode(mobile.assetMode),
-    devServerUrl: normalizeText(mobile.devServerUrl),
-    apiBaseUrl: normalizeText(mobile.apiBaseUrl),
-    auth: Object.freeze({
-      callbackPath: normalizeMobileCallbackPath(auth.callbackPath, {
-        fallback: DEFAULT_MOBILE_AUTH_CONFIG.callbackPath
-      }),
-      customScheme: normalizeLowerText(auth.customScheme),
-      appLinkDomains: Object.freeze([
-        ...new Set(
-          normalizeUniqueTextList(auth.appLinkDomains, {
-            acceptSingle: true
-          }).map((entry) => normalizeLowerText(entry))
-        )
-      ])
-    }),
-    android: Object.freeze({
-      packageName: normalizeText(android.packageName),
-      minSdk: normalizePositiveInteger(android.minSdk, {
-        fallback: DEFAULT_MOBILE_ANDROID_CONFIG.minSdk
-      }),
-      targetSdk: normalizePositiveInteger(android.targetSdk, {
-        fallback: DEFAULT_MOBILE_ANDROID_CONFIG.targetSdk
-      }),
-      versionCode: normalizePositiveInteger(android.versionCode, {
-        fallback: DEFAULT_MOBILE_ANDROID_CONFIG.versionCode
-      }),
-      versionName: normalizeText(android.versionName, {
-        fallback: DEFAULT_MOBILE_ANDROID_CONFIG.versionName
-      })
-    })
-  });
-}
-
 function ensureNonEmptyText(value, label = "value") {
   const normalized = normalizeText(value);
   if (!normalized) {
@@ -368,8 +266,6 @@ export {
   normalizeQueryToken,
   normalizeObject,
   normalizeIfInSource,
-  normalizeIfPresent,
-  normalizeOrNull,
   isRecord,
   normalizeArray,
   normalizeUniqueTextList,
@@ -379,9 +275,5 @@ export {
   normalizeRecordId,
   normalizeOpaqueId,
   normalizeOneOf,
-  normalizeMobileAssetMode,
-  normalizeMobileCallbackPath,
-  normalizeMobileConfig,
-  normalizeMobileStrategy,
   ensureNonEmptyText
 };

package/shared/support/normalize.test.js

@@ -7,10 +7,6 @@ import {
   normalizeFiniteInteger,
   normalizeFiniteNumber,
   normalizeIfInSource,
-  normalizeIfPresent,
-  normalizeMobileCallbackPath,
-  normalizeMobileConfig,
-  normalizeOrNull,
   normalizeRecordId,
   normalizeOpaqueId,
   normalizePositiveInteger,
@@ -166,26 +162,6 @@ test("normalizeIfInSource validates target and function arguments", () => {
   );
 });
 
-test("normalizeIfPresent normalizes non-nullish values and preserves nullish values", () => {
-  assert.equal(normalizeIfPresent("  Ada  ", normalizeText), "Ada");
-  assert.equal(normalizeIfPresent(null, normalizeText), null);
-  assert.equal(normalizeIfPresent(undefined, normalizeText), undefined);
-  assert.throws(
-    () => normalizeIfPresent("Ada", null),
-    /requires normalizer function/
-  );
-});
-
-test("normalizeOrNull normalizes non-nullish values and coerces nullish to null", () => {
-  assert.equal(normalizeOrNull("  Ada  ", normalizeText), "Ada");
-  assert.equal(normalizeOrNull(null, normalizeText), null);
-  assert.equal(normalizeOrNull(undefined, normalizeText), null);
-  assert.throws(
-    () => normalizeOrNull("Ada", null),
-    /requires normalizer function/
-  );
-});
-
 test("normalizeRecordId accepts canonical string, safe integer, and bigint identifiers", () => {
   const unsafeNumericId = Number(9007199254740993n);
   assert.equal(normalizeRecordId("  7  "), "7");
@@ -224,113 +200,3 @@ test("normalizeUniqueTextList trims, dedupes, and supports optional single value
     ["one"]
   );
 });
-
-test("normalizeMobileCallbackPath normalizes auth callback paths", () => {
-  assert.equal(normalizeMobileCallbackPath("auth/login"), "/auth/login");
-  assert.equal(normalizeMobileCallbackPath("/auth/login"), "/auth/login");
-  assert.equal(
-    normalizeMobileCallbackPath("", {
-      fallback: "/login/callback"
-    }),
-    "/login/callback"
-  );
-});
-
-test("normalizeMobileConfig normalizes the mobile config contract", () => {
-  const mobileConfig = normalizeMobileConfig({
-    enabled: true,
-    strategy: " Capacitor ",
-    appId: "com.example.convict",
-    appName: "Convict",
-    assetMode: " dev_server ",
-    devServerUrl: " http://192.168.1.10:5173 ",
-    apiBaseUrl: " https://api.example.com ",
-    auth: {
-      callbackPath: "auth/login",
-      customScheme: " Convict ",
-      appLinkDomains: ["App.Example.com", " app.example.com "]
-    },
-    android: {
-      packageName: "com.example.convict",
-      minSdk: "28",
-      targetSdk: "35",
-      versionCode: "4",
-      versionName: "2.0.0"
-    }
-  });
-
-  assert.deepEqual(mobileConfig, {
-    enabled: true,
-    strategy: "capacitor",
-    appId: "com.example.convict",
-    appName: "Convict",
-    assetMode: "dev_server",
-    devServerUrl: "http://192.168.1.10:5173",
-    apiBaseUrl: "https://api.example.com",
-    auth: {
-      callbackPath: "/auth/login",
-      customScheme: "convict",
-      appLinkDomains: ["app.example.com"]
-    },
-    android: {
-      packageName: "com.example.convict",
-      minSdk: 28,
-      targetSdk: 35,
-      versionCode: 4,
-      versionName: "2.0.0"
-    }
-  });
-});
-
-test("normalizeMobileConfig applies defaults for missing fields", () => {
-  const mobileConfig = normalizeMobileConfig({
-    auth: {
-      appLinkDomains: "app.example.com"
-    },
-    android: {
-      minSdk: "bad",
-      targetSdk: 0,
-      versionCode: "",
-      versionName: ""
-    }
-  });
-
-  assert.deepEqual(mobileConfig, {
-    enabled: false,
-    strategy: "",
-    appId: "",
-    appName: "",
-    assetMode: "bundled",
-    devServerUrl: "",
-    apiBaseUrl: "",
-    auth: {
-      callbackPath: "/auth/login",
-      customScheme: "",
-      appLinkDomains: ["app.example.com"]
-    },
-    android: {
-      packageName: "",
-      minSdk: 26,
-      targetSdk: 35,
-      versionCode: 1,
-      versionName: "1.0.0"
-    }
-  });
-});
-
-test("normalizeMobileConfig preserves explicit false values from string input", () => {
-  const mobileConfig = normalizeMobileConfig({
-    enabled: "false"
-  });
-
-  assert.equal(mobileConfig.enabled, false);
-});
-
-test("normalizeMobileConfig rejects invalid assetMode values", () => {
-  assert.throws(
-    () => normalizeMobileConfig({
-      assetMode: "weird"
-    }),
-    /config\.mobile\.assetMode must be "bundled" or "dev_server"\./u
-  );
-});

package/shared/{actions/actionContributorHelpers.test.js → support/permissions.test.js}

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { hasPermission } from "./actionContributorHelpers.js";
+import { hasPermission } from "./permissions.js";
 
 test("hasPermission allows wildcard and direct matches", () => {
   assert.equal(hasPermission(["*"], "workspace.billing.manage"), true);

package/shared/support/returnToPath.js

@@ -1,5 +1,17 @@
 import { normalizePathname } from "../surface/paths.js";
 
+const SAME_ORIGIN_PROBE = "http://return-to.invalid";
+
+// Browsers read "/\\host" and "/<tab>/host" as another site, so a path counts
+// only if it resolves on the page's own origin.
+function staysOnSameOrigin(path) {
+  try {
+    return new URL(path, SAME_ORIGIN_PROBE).origin === SAME_ORIGIN_PROBE;
+  } catch {
+    return false;
+  }
+}
+
 function normalizeHttpOrigin(value = "") {
   const rawValue = String(value || "").trim();
   if (!rawValue) {
@@ -77,24 +89,6 @@ function normalizeBlockedPathnames(blockedPathnames = []) {
   return normalizedPathnames;
 }
 
-function resolveAllowedOriginsFromPlacementContext(contextValue = null, { includeWindowOrigin = true } = {}) {
-  const seedOrigins = [];
-
-  if (includeWindowOrigin && typeof window === "object" && window?.location?.origin) {
-    appendNormalizedOrigin(seedOrigins, window.location.origin);
-  }
-
-  const surfaceConfig =
-    contextValue && typeof contextValue === "object" && contextValue.surfaceConfig && typeof contextValue.surfaceConfig === "object"
-      ? contextValue.surfaceConfig
-      : {};
-  const surfacesById =
-    surfaceConfig.surfacesById && typeof surfaceConfig.surfacesById === "object" ? surfaceConfig.surfacesById : {};
-  return resolveAllowedOriginsFromSurfaceDefinitions(surfacesById, {
-    seedOrigins
-  });
-}
-
 function normalizeReturnToPath(
   value,
   {
@@ -113,6 +107,9 @@ function normalizeReturnToPath(
   const normalizedBlockedPathnames = normalizeBlockedPathnames(blockedPathnames);
 
   if (rawValue.startsWith("/") && !rawValue.startsWith("//")) {
+    if (!staysOnSameOrigin(rawValue)) {
+      return fallback;
+    }
     const normalizedPathname = normalizePathname(rawValue);
     if (normalizedBlockedPathnames.includes(normalizedPathname)) {
       return fallback;
@@ -148,6 +145,5 @@ export {
   normalizeAllowedOrigins,
   normalizeHttpOrigin,
   normalizeReturnToPath,
-  resolveAllowedOriginsFromSurfaceDefinitions,
-  resolveAllowedOriginsFromPlacementContext
+  resolveAllowedOriginsFromSurfaceDefinitions
 };

package/shared/support/returnToPath.test.js

@@ -5,8 +5,7 @@ import {
   normalizeAllowedOrigins,
   normalizeHttpOrigin,
   normalizeReturnToPath,
-  resolveAllowedOriginsFromSurfaceDefinitions,
-  resolveAllowedOriginsFromPlacementContext
+  resolveAllowedOriginsFromSurfaceDefinitions
 } from "./returnToPath.js";
 
 test("normalizeHttpOrigin keeps valid http origins only", () => {
@@ -88,36 +87,9 @@ test("resolveAllowedOriginsFromSurfaceDefinitions includes seed origins and surf
   ]);
 });
 
-test("resolveAllowedOriginsFromPlacementContext collects current and surface origins", () => {
-  const originalWindow = globalThis.window;
-  globalThis.window = {
-    location: {
-      origin: "https://current.example.com"
-    }
-  };
-
-  try {
-    const origins = resolveAllowedOriginsFromPlacementContext({
-      surfaceConfig: {
-        surfacesById: {
-          home: { origin: "https://home.example.com" },
-          app: { origin: "https://app.example.com" },
-          duplicate: { origin: "https://home.example.com" },
-          invalid: { origin: "mailto:hello@example.com" }
-        }
-      }
-    });
-
-    assert.deepEqual(origins, [
-      "https://current.example.com",
-      "https://home.example.com",
-      "https://app.example.com"
-    ]);
-  } finally {
-    if (typeof originalWindow === "undefined") {
-      delete globalThis.window;
-    } else {
-      globalThis.window = originalWindow;
-    }
+test("normalizeReturnToPath refuses paths a browser reads as another site", () => {
+  for (const value of ["/\\evil.example", "/\\/evil.example/x", "/\t/evil.example", "/\n/evil.example", "\\\\evil.example"]) {
+    assert.equal(normalizeReturnToPath(value, { fallback: "/home" }), "/home", JSON.stringify(value));
   }
+  assert.equal(normalizeReturnToPath("/a/b?c=1#d", { fallback: "/home" }), "/a/b?c=1#d");
 });

package/shared/support/shellLayoutTargets.js

@@ -3,28 +3,9 @@ import {
   normalizeText
 } from "./normalize.js";
 
-const SHELL_OUTLET_TAG_PATTERN = /<ShellOutlet\b([^>]*)\/?>/g;
-const ATTRIBUTE_PATTERN = /([:@]?[A-Za-z_][A-Za-z0-9_-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'))?/g;
 const PLACEMENT_LAYOUT_CLASSES = Object.freeze(["compact", "medium", "expanded"]);
 const WEB_PLACEMENT_SURFACE_ANY = "*";
 
-function parseTagAttributes(attributesSource = "") {
-  const attributes = {};
-  const source = String(attributesSource || "");
-  for (const match of source.matchAll(ATTRIBUTE_PATTERN)) {
-    const attributeName = normalizeText(match[1]);
-    if (!attributeName) {
-      continue;
-    }
-
-    const hasValue = match[2] != null || match[3] != null;
-    const attributeValue = hasValue ? String(match[2] ?? match[3] ?? "") : true;
-    attributes[attributeName] = attributeValue;
-  }
-
-  return attributes;
-}
-
 function normalizeShellOutletTargetId(value = "") {
   const normalizedValue = normalizeText(value);
   if (!normalizedValue) {
@@ -250,126 +231,9 @@ function normalizePlacementTopologyDefinition(
   });
 }
 
-function resolveShellOutletTargetParts(
-  {
-    target = ""
-  } = {}
-) {
-  const normalizedTargetId = normalizeShellOutletTargetId(target);
-  if (!normalizedTargetId) {
-    return null;
-  }
-
-  return Object.freeze({
-    id: normalizedTargetId
-  });
-}
-
-function findShellOutletTargetById(targets = [], targetId = "") {
-  const entries = Array.isArray(targets) ? targets : [];
-  const normalizedTargetId = normalizeShellOutletTargetId(targetId);
-  if (!normalizedTargetId) {
-    return null;
-  }
-
-  return entries.find((entry) => normalizeShellOutletTargetId(entry?.id) === normalizedTargetId) || null;
-}
-
-function describeShellOutletTargets(targets = []) {
-  return (Array.isArray(targets) ? targets : [])
-    .map((entry) => normalizeShellOutletTargetId(entry?.id))
-    .filter(Boolean)
-    .join(", ");
-}
-
-function isDefaultAttributeEnabled(value) {
-  if (value === true) {
-    return true;
-  }
-
-  const normalized = normalizeText(value).toLowerCase();
-  if (!normalized) {
-    return true;
-  }
-
-  return normalized !== "false" && normalized !== "0" && normalized !== "no" && normalized !== "off";
-}
-
-function normalizeShellOutletTargetRecord(
-  value = {},
-  {
-    context = "shell layout"
-  } = {}
-) {
-  const record = normalizeObject(value);
-  const resolvedContext = normalizeText(context) || "shell layout";
-  const targetParts = resolveShellOutletTargetParts(
-    {
-      target: record.target
-    },
-    { context: resolvedContext }
-  );
-  if (!targetParts) {
-    return null;
-  }
-
-  return Object.freeze({
-    ...targetParts,
-    default:
-      Object.hasOwn(record, "default") &&
-      isDefaultAttributeEnabled(record.default)
-  });
-}
-
-function discoverShellOutletTargetsFromVueSource(
-  source = "",
-  {
-    context = "shell layout",
-    enforceSingleDefault = true
-  } = {}
-) {
-  const sourceText = String(source || "");
-  const resolvedContext = normalizeText(context) || "shell layout";
-  const targetById = new Map();
-  let defaultTargetId = "";
-
-  for (const tagMatch of sourceText.matchAll(SHELL_OUTLET_TAG_PATTERN)) {
-    const attributes = parseTagAttributes(tagMatch[1]);
-    const normalizedTarget = normalizeShellOutletTargetRecord(attributes, {
-      context: resolvedContext
-    });
-    if (!normalizedTarget) {
-      continue;
-    }
-    if (targetById.has(normalizedTarget.id)) {
-      throw new Error(`${resolvedContext} contains duplicate ShellOutlet target "${normalizedTarget.id}".`);
-    }
-
-    if (normalizedTarget.default) {
-      if (enforceSingleDefault === true && defaultTargetId) {
-        throw new Error(
-          `${resolvedContext} defines multiple default ShellOutlet targets: "${defaultTargetId}" and "${normalizedTarget.id}".`
-        );
-      }
-      if (!defaultTargetId) {
-        defaultTargetId = normalizedTarget.id;
-      }
-    }
-
-    targetById.set(normalizedTarget.id, normalizedTarget);
-  }
-
-  return Object.freeze({
-    targets: Object.freeze([...targetById.values()]),
-    defaultTargetId
-  });
-}
-
 export {
   PLACEMENT_LAYOUT_CLASSES,
-  describeShellOutletTargets,
-  discoverShellOutletTargetsFromVueSource,
-  findShellOutletTargetById,
+  WEB_PLACEMENT_SURFACE_ANY,
   normalizePlacementKind,
   normalizePlacementLayoutClass,
   normalizePlacementOwnerId,
@@ -380,7 +244,5 @@ export {
   normalizePlacementTopologyVariant,
   normalizeSemanticPlacementId,
   normalizeShellOutletTargetId,
-  normalizeShellOutletTargetRecord,
-  resolvePlacementTargetReference,
-  resolveShellOutletTargetParts
+  resolvePlacementTargetReference
 };