@craft-native/ios 0.0.449 → 0.0.464

package/README.md

@@ -77,6 +77,15 @@ use their own temporary namespace and are erased on the next native launch after
 an interruption or process termination, including the earlier recorder's M4A files.
 Picked files and downloads retain their separate lifetime.
 
+For cancellation diagnostics, the native `voice-recording` log records the
+removal queue delay, removal duration, ownership check and whether the path still
+exists, without including the path or audio content. The blocked-encoder unit
+test retains the same receipt alongside each file-absence predicate observation
+in its XCResult. Its original two-second cleanup bound still applies before the
+encoder is released. These observations distinguish delayed removal from a
+missed observation; a later passing run alone does not explain issue #448's
+original timeout.
+
 ### Device Access
 
 - **Camera & Gallery** - Take photos or pick from gallery
@@ -1420,4 +1429,60 @@ when available. `monospace`/`ui-monospace`, `serif`/`ui-serif` and
 weight, italic style and system text scaling. A missing custom face falls through
 to the next family rather than silently replacing a requested mono font with sans.
 
-The simulator driver requires a successful HTTP response from each control-server `exec` hook. A failed or unavailable hook fails XCTest and stops the journey before its next command.
+The simulator driver requires a successful HTTP response from each control-server `exec` hook. A failed or unavailable hook fails XCTest and stops the journey before its next command. A successful hook may return a message or HTTP 204 with no body. Legacy shell responses (`exit <code> ...`) must report exactly `0`; nonzero or malformed exit statuses and the legacy `no such hook` response fail the journey.
+
+`longpressid` establishes keyboard focus before holding a native text field or text view, so the gesture opens its edit menu. Typing into an already focused control preserves its current selection. Other elements keep their ordinary long-press behavior. The real native text-editing regression runs with `CRAFT_DRIVER_SIMULATOR=<owned-uuid> CRAFT_DRIVER_TEXT_RESULT=<retained-path>.xcresult bun packages/ios/scripts/test-driver-text.ts`; it uses the existing selection and typing commands to edit and clear Unicode values.
+
+The delayed-focus fixture observes the complete value with the existing bounded
+`valueid` check after one tap and one typing call. Cold runs reproduced empty
+and intermediate `"Gr"` accessibility values while native callbacks completed
+`"Grüße"`; an immediate equality assertion raced that propagation. The fixture
+also verifies that a focused field whose delegate rejects input fails the value
+check, so waiting cannot turn missing text into a pass.
+
+It retains `native-focus-after-type` and `native-rejected-input` XCTest attachments
+and prints `FOCUS_EVIDENCE` with the first observed value, native focus requests,
+keyboard notifications, replacement ranges, and editing callbacks. The event
+recorder stays in memory and is read on demand, without publishing accessibility
+updates during typing. These receipts distinguish focus, input delivery, and
+value observation; they do not establish the cause of the original external
+browser checkout failure.
+
+### Constraining native path parameters
+
+`nativeScreenConstraints` keeps a parameter route from claiming paths owned by
+website pages. Rules use the exact `nativeScreens` route key and named parameter:
+
+```ts
+nativeScreens: { '/:username': 'Profile', '/me': 'Account' },
+nativeScreenConstraints: {
+  '/:username': {
+    username: { pattern: '[a-z0-9]+(?:-[a-z0-9]+)*', exclude: ['terms', 'privacy'], normalize: 'lowercase' },
+  },
+},
+```
+
+Patterns match the complete decoded value case-sensitively. Optional
+`normalize: 'lowercase'` lowercases decoded parameters and excluded values before
+validation, independently of the device locale; matched parameters carry that
+normalized value. This avoids the incompatible Unicode case-folding behavior of
+regex engines. Use regular expressions supported by JavaScript, Foundation and
+Kotlin; invalid patterns fail closed. Constraints run before query parameters are added, so a query
+cannot replace a path parameter. Static routes still win. Unmatched paths retain
+the shell's normal website fallback. Invalid configuration is rejected when the
+project is generated. The browser-safe `craft-native/mobile` entry exports
+`matchNativePath(screens, path, constraints)` for the app's own resolver.
+
+### Boolean tap failure evidence
+
+The shared simulator driver's `tapid` emits a `BOOLEAN_TAP` JSON record for
+boolean-valued controls. It includes the enabled state and value before/after
+the single gesture, plus its initial frame and the flip verdict. The existing
+1.5-second observation deadline remains unchanged; disabled controls still fail
+instead of being retried or silently accepted.
+
+This matters for #449: the original HQ agreement source disables its switches
+while policy loading is pending, while the journey checks presence/scrolling.
+That is a hypothesis to verify against pre-tap state, not an established cause of
+the original dropped tap. The record distinguishes a disabled target from an
+enabled control whose value failed to change without altering either scenario.

package/dist/cli.js

@@ -5,6 +5,214 @@
 import { parseArgs } from "util";
 import { resolve as resolve3 } from "path";
 
+// ../typescript/src/native-notifications.ts
+function nativeNotificationProblems(categories, nativeApp, renderer) {
+  if (categories === undefined)
+    return [];
+  if (!Array.isArray(categories))
+    return ["notificationCategories must be an array."];
+  const problems = [];
+  const categoryIds = new Set;
+  const object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+  const text = (value) => typeof value === "string" && value.trim().length > 0;
+  for (const [index, category] of categories.entries()) {
+    const field = `notificationCategories[${index}]`;
+    if (!object(category) || !text(category.id)) {
+      problems.push(`${field} needs a nonempty id.`);
+      continue;
+    }
+    if (categoryIds.has(category.id))
+      problems.push(`${field}.id must be unique.`);
+    categoryIds.add(category.id);
+    if (!Array.isArray(category.actions) || category.actions.length < 1 || category.actions.length > 3) {
+      problems.push(`${field}.actions must contain 1\u20133 actions for both platforms.`);
+      continue;
+    }
+    const actionIds = new Set;
+    for (const [position, action] of category.actions.entries()) {
+      const path = `${field}.actions[${position}]`;
+      if (!object(action) || !text(action.id) || !text(action.title)) {
+        problems.push(`${path} needs a nonempty id and title.`);
+        continue;
+      }
+      if (action.id.startsWith("com.apple.") || actionIds.has(action.id))
+        problems.push(`${path}.id must be unique and must not use Apple's reserved prefix.`);
+      actionIds.add(action.id);
+      for (const flag of ["destructive", "foreground", "authenticationRequired"]) {
+        if (action[flag] !== undefined && typeof action[flag] !== "boolean")
+          problems.push(`${path}.${flag} must be a boolean.`);
+      }
+      if (!nativeApp?.trim() && (action.foreground !== true || renderer === "native"))
+        problems.push(`${path} requires nativeApp to receive native/background action events.`);
+      if (action.textInput !== undefined && (!object(action.textInput) || !text(action.textInput.buttonTitle) || action.textInput.placeholder !== undefined && typeof action.textInput.placeholder !== "string")) {
+        problems.push(`${path}.textInput needs a buttonTitle and an optional string placeholder.`);
+      }
+    }
+  }
+  return problems;
+}
+
+// ../typescript/src/native-routing.ts
+function applyNativeParameterConstraints(params, rules) {
+  if (rules === undefined)
+    return true;
+  if (!rules || typeof rules !== "object" || Array.isArray(rules))
+    return false;
+  for (const [name, rule] of Object.entries(rules)) {
+    let value = params[name];
+    if (typeof value !== "string" || !rule || typeof rule !== "object" || Array.isArray(rule))
+      return false;
+    if (Object.keys(rule).some((key) => !["pattern", "exclude", "normalize"].includes(key)))
+      return false;
+    if (rule.normalize !== undefined && rule.normalize !== "lowercase")
+      return false;
+    if (rule.normalize === "lowercase")
+      value = value.toLowerCase();
+    if (rule.exclude !== undefined) {
+      if (!Array.isArray(rule.exclude) || rule.exclude.some((item) => typeof item !== "string"))
+        return false;
+      if (rule.exclude.some((item) => (rule.normalize === "lowercase" ? item.toLowerCase() : item) === value))
+        return false;
+    }
+    if (rule.pattern !== undefined) {
+      if (typeof rule.pattern !== "string")
+        return false;
+      try {
+        const matched = new RegExp(`^(?:${rule.pattern})$`).exec(value);
+        if (!matched || matched[0] !== value)
+          return false;
+      } catch {
+        return false;
+      }
+    }
+    params[name] = value;
+  }
+  return true;
+}
+function nativeRouteConstraintProblems(screens, constraints) {
+  const problems = [];
+  if (constraints === undefined)
+    return problems;
+  if (!constraints || typeof constraints !== "object" || Array.isArray(constraints))
+    return ["nativeScreenConstraints must name route parameter constraints."];
+  for (const [route, rules] of Object.entries(constraints)) {
+    const prefix = `nativeScreenConstraints[${JSON.stringify(route)}]`;
+    if (!Object.prototype.hasOwnProperty.call(screens ?? {}, route))
+      problems.push(`${prefix} names no native screen route.`);
+    if (!rules || typeof rules !== "object" || Array.isArray(rules)) {
+      problems.push(`${prefix} must name parameter constraints.`);
+      continue;
+    }
+    const names = route.split("/").filter((part) => part.startsWith(":")).map((part) => part.slice(1));
+    for (const [name, rule] of Object.entries(rules)) {
+      const field = `${prefix}[${JSON.stringify(name)}]`;
+      if (!names.includes(name))
+        problems.push(`${field} names no path parameter.`);
+      if (!rule || typeof rule !== "object" || Array.isArray(rule)) {
+        problems.push(`${field} must be a parameter constraint.`);
+        continue;
+      }
+      if (Object.keys(rule).some((key) => !["pattern", "exclude", "normalize"].includes(key)))
+        problems.push(`${field} has an unknown constraint field.`);
+      if (rule.exclude !== undefined && (!Array.isArray(rule.exclude) || rule.exclude.some((value) => typeof value !== "string")))
+        problems.push(`${field}.exclude must contain strings.`);
+      if (rule.normalize !== undefined && rule.normalize !== "lowercase")
+        problems.push(`${field}.normalize must be lowercase.`);
+      if (rule.pattern !== undefined) {
+        try {
+          if (typeof rule.pattern !== "string")
+            throw new Error("not a string");
+          new RegExp(`^(?:${rule.pattern})$`);
+        } catch {
+          problems.push(`${field}.pattern must be a valid regular expression.`);
+        }
+      }
+    }
+  }
+  return problems;
+}
+function normalizeNativePath(raw) {
+  if (typeof raw !== "string")
+    return null;
+  let path = raw;
+  const cut = path.search(/[?#]/);
+  if (cut >= 0)
+    path = path.slice(0, cut);
+  if (!path.startsWith("/"))
+    return null;
+  path = path.replace(/\/{2,}/g, "/");
+  if (path.length > 1 && path.endsWith("/"))
+    path = path.slice(0, -1);
+  return path;
+}
+function routeSegments(path) {
+  return path === "/" ? [] : path.slice(1).split("/");
+}
+function matchNativePath(nativeScreens, raw, constraints) {
+  if (constraints !== undefined && (!constraints || typeof constraints !== "object" || Array.isArray(constraints)))
+    return null;
+  const path = normalizeNativePath(raw);
+  if (path === null)
+    return null;
+  const routes = Object.entries(nativeScreens ?? {}).map(([pattern, screen]) => ({ key: pattern, pattern: normalizeNativePath(pattern), screen })).filter((route) => route.pattern !== null && !!route.screen).map((route) => ({ ...route, segments: routeSegments(route.pattern) }));
+  const wild = (segments) => segments.at(-1) === "*" ? 1 : 0;
+  const fixed = (segments) => segments.filter((s) => s !== "*" && !s.startsWith(":")).length;
+  routes.sort((a, b) => wild(a.segments) - wild(b.segments) || fixed(b.segments) - fixed(a.segments) || b.segments.length - a.segments.length || (a.pattern < b.pattern ? -1 : a.pattern > b.pattern ? 1 : 0));
+  const decode = (value) => {
+    try {
+      return decodeURIComponent(value);
+    } catch {
+      return value;
+    }
+  };
+  const parts = routeSegments(path);
+  for (const route of routes) {
+    const params = {};
+    let matched = true;
+    for (let i = 0;i < route.segments.length; i++) {
+      const segment = route.segments[i];
+      if (segment === "*") {
+        params["*"] = parts.slice(i).join("/");
+        break;
+      }
+      if (i >= parts.length) {
+        matched = false;
+        break;
+      }
+      if (segment.startsWith(":")) {
+        if (!parts[i]) {
+          matched = false;
+          break;
+        }
+        params[segment.slice(1)] = decode(parts[i]);
+      } else if (segment !== parts[i]) {
+        matched = false;
+        break;
+      }
+    }
+    if (!matched)
+      continue;
+    if (route.segments.at(-1) !== "*" && route.segments.length !== parts.length)
+      continue;
+    if (!applyNativeParameterConstraints(params, constraints?.[route.key]))
+      continue;
+    const query = raw.indexOf("?");
+    if (query >= 0) {
+      for (const item of raw.slice(query + 1).split("#")[0].split("&")) {
+        if (!item)
+          continue;
+        const [rawKey = "", ...rest] = item.split("=");
+        const key = decode(rawKey);
+        if (!key || key in params)
+          continue;
+        params[key] = decode(rest.join("=").replace(/\+/g, " "));
+      }
+    }
+    return { path, screen: route.screen, params };
+  }
+  return null;
+}
+
 // src/index.ts
 import { gzipSync } from "zlib";
 
@@ -285,83 +493,6 @@ function resolveCraftVersion(startDir = import.meta.dir) {
   return "0.0.0";
 }
 var CRAFT_VERSION = resolveCraftVersion();
-function normalizeNativePath(raw) {
-  if (typeof raw !== "string")
-    return null;
-  let path = raw;
-  const cut = path.search(/[?#]/);
-  if (cut >= 0)
-    path = path.slice(0, cut);
-  if (!path.startsWith("/"))
-    return null;
-  path = path.replace(/\/{2,}/g, "/");
-  if (path.length > 1 && path.endsWith("/"))
-    path = path.slice(0, -1);
-  return path;
-}
-function routeSegments(path) {
-  return path === "/" ? [] : path.slice(1).split("/");
-}
-function matchNativePath(nativeScreens, raw) {
-  const path = normalizeNativePath(raw);
-  if (path === null)
-    return null;
-  const routes = Object.entries(nativeScreens ?? {}).map(([pattern, screen]) => ({ pattern: normalizeNativePath(pattern), screen })).filter((route) => route.pattern !== null && !!route.screen).map((route) => ({ ...route, segments: routeSegments(route.pattern) }));
-  const wild = (segments) => segments.at(-1) === "*" ? 1 : 0;
-  const fixed = (segments) => segments.filter((s) => s !== "*" && !s.startsWith(":")).length;
-  routes.sort((a, b) => wild(a.segments) - wild(b.segments) || fixed(b.segments) - fixed(a.segments) || b.segments.length - a.segments.length || (a.pattern < b.pattern ? -1 : a.pattern > b.pattern ? 1 : 0));
-  const decode = (value) => {
-    try {
-      return decodeURIComponent(value);
-    } catch {
-      return value;
-    }
-  };
-  const parts = routeSegments(path);
-  for (const route of routes) {
-    const params = {};
-    let matched = true;
-    for (let i = 0;i < route.segments.length; i++) {
-      const segment = route.segments[i];
-      if (segment === "*") {
-        params["*"] = parts.slice(i).join("/");
-        break;
-      }
-      if (i >= parts.length) {
-        matched = false;
-        break;
-      }
-      if (segment.startsWith(":")) {
-        if (!parts[i]) {
-          matched = false;
-          break;
-        }
-        params[segment.slice(1)] = decode(parts[i]);
-      } else if (segment !== parts[i]) {
-        matched = false;
-        break;
-      }
-    }
-    if (!matched)
-      continue;
-    if (route.segments.at(-1) !== "*" && route.segments.length !== parts.length)
-      continue;
-    const query = raw.indexOf("?");
-    if (query >= 0) {
-      for (const item of raw.slice(query + 1).split("#")[0].split("&")) {
-        if (!item)
-          continue;
-        const [rawKey = "", ...rest] = item.split("=");
-        const key = decode(rawKey);
-        if (!key || key in params)
-          continue;
-        params[key] = decode(rest.join("=").replace(/\+/g, " "));
-      }
-    }
-    return { path, screen: route.screen, params };
-  }
-  return null;
-}
 function isHybrid(config) {
   return (config.renderer ?? "web") === "web" && Object.keys(config.nativeScreens ?? {}).length > 0;
 }
@@ -382,8 +513,9 @@ function nativeStartPath(config) {
   }
 }
 function hybridConfigProblems(config) {
-  const problems = [];
+  const problems = nativeNotificationProblems(config.notificationCategories, config.nativeApp, config.renderer);
   const screens = Object.entries(config.nativeScreens ?? {});
+  problems.push(...nativeRouteConstraintProblems(config.nativeScreens, config.nativeScreenConstraints));
   for (const [pattern, screen] of screens) {
     if (normalizeNativePath(pattern) !== pattern || /[?#]/.test(pattern))
       problems.push(`nativeScreens path "${pattern}" must be an absolute path with no query, hash or trailing slash.`);
@@ -407,11 +539,11 @@ function hybridConfigProblems(config) {
   }
   if (hasNativeRoutes(config)) {
     for (const id of ids) {
-      if (!matchNativePath(config.nativeScreens, id))
+      if (!matchNativePath(config.nativeScreens, id, config.nativeScreenConstraints))
         problems.push(`Tab "${id}" is not a nativeScreens path; with renderer: "native" every tab must be a native screen.`);
     }
     const start = nativeStartPath(config);
-    if (!matchNativePath(config.nativeScreens, start))
+    if (!matchNativePath(config.nativeScreens, start, config.nativeScreenConstraints))
       problems.push(`The start path "${start}" (from devServerURL) is not a nativeScreens path; with renderer: "native" the app must start on a native screen.`);
   }
   if (config.nativeApp !== undefined) {
@@ -691,6 +823,78 @@ function validateHealthKitBackground(config) {
   if (!["immediate", "hourly", "daily", "weekly"].includes(config.healthKitBackgroundFrequency ?? "hourly"))
     throw new Error("healthKitBackgroundFrequency must be immediate, hourly, daily or weekly");
 }
+function validateNotificationAttachments(config) {
+  if (config.enableNotificationAttachments !== undefined && typeof config.enableNotificationAttachments !== "boolean")
+    throw new Error("enableNotificationAttachments must be a boolean");
+  if (config.enableNotificationAttachments && config.enablePushNotifications !== true)
+    throw new Error("enableNotificationAttachments requires enablePushNotifications");
+}
+var notificationServiceInclude = `  - path: CraftNotificationService.yml
+`;
+function syncNotificationService(output, config) {
+  validateNotificationAttachments(config);
+  const spec = join4(output, "CraftNotificationService.yml");
+  if (!config.enableNotificationAttachments) {
+    writeFileSync2(spec, `{}
+`);
+    return;
+  }
+  const name = productName(config.appName);
+  const folder = join4(output, "NotificationService");
+  mkdirSync(folder, { recursive: true });
+  const source = readFileSync2(join4(TEMPLATES_DIR, "CraftNotificationService.swift"), "utf8");
+  const destination = join4(folder, "CraftNotificationService.swift");
+  if (!existsSync2(destination) || readFileSync2(destination, "utf8") !== source)
+    writeFileSync2(destination, source);
+  writeFileSync2(join4(folder, "Info.plist"), `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>CFBundleExecutable</key><string>$(EXECUTABLE_NAME)</string>
+  <key>CFBundleIdentifier</key><string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+  <key>CFBundleName</key><string>$(PRODUCT_NAME)</string>
+  <key>CFBundlePackageType</key><string>XPC!</string>
+  <key>CFBundleShortVersionString</key><string>$(MARKETING_VERSION)</string>
+  <key>CFBundleVersion</key><string>$(CURRENT_PROJECT_VERSION)</string>
+  <key>NSExtension</key><dict>
+    <key>NSExtensionPointIdentifier</key><string>com.apple.usernotifications.service</string>
+    <key>NSExtensionPrincipalClass</key><string>$(PRODUCT_MODULE_NAME).CraftNotificationService</string>
+  </dict>
+</dict></plist>
+`);
+  writeFileSync2(spec, `targets:
+  ${name}:
+    dependencies:
+      - target: ${name}NotificationService
+        embed: true
+  ${name}NotificationService:
+    type: app-extension
+    platform: iOS
+    deploymentTarget: "${config.iosVersion || "15.0"}"
+    sources:
+      - NotificationService
+    settings:
+      INFOPLIST_FILE: NotificationService/Info.plist
+      PRODUCT_NAME: "$(TARGET_NAME)"
+      PRODUCT_BUNDLE_IDENTIFIER: ${config.bundleId}.notificationservice
+      SWIFT_VERSION: "5.0"
+      APPLICATION_EXTENSION_API_ONLY: YES
+      SKIP_INSTALL: YES
+`);
+  const project = join4(output, "project.yml");
+  if (existsSync2(project)) {
+    const text = readFileSync2(project, "utf8");
+    const include = Bun.YAML.parse(text).include;
+    const includes = Array.isArray(include) ? include : [include];
+    const present = includes.some((entry) => entry === "CraftNotificationService.yml" || entry && typeof entry === "object" && ("path" in entry) && entry.path === "CraftNotificationService.yml");
+    if (!present) {
+      if (/^include:/m.test(text) && !/^include:[ \t]*\r?\n[ \t]+-/m.test(text))
+        throw new Error("Add a CraftNotificationService.yml entry to the project.yml include list");
+      writeFileSync2(project, /^include:/m.test(text) ? text.replace(/^include:[ \t]*\r?\n/m, `include:
+${notificationServiceInclude}`) : `include:
+${notificationServiceInclude}${text}`);
+    }
+  }
+}
 function renderEntitlements(config) {
   validateHealthKitBackground(config);
   const entries = [];
@@ -1161,6 +1365,7 @@ function productName(name) {
   return /^\d/.test(joined) ? `App${joined}` : joined;
 }
 function writeShell(output, config) {
+  validateNotificationAttachments(config);
   if (!config.appName || !/^[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+$/.test(config.bundleId))
     throw new Error("The iOS shell needs an appName and a valid bundleId in craft.config.json.");
   const writeSource = (path, source) => {
@@ -1208,6 +1413,7 @@ function writeShell(output, config) {
     const source = readFileSync2(join4(TEMPLATES_DIR, template), "utf8").replace(/\{\{APP_NAME\}\}/g, name).replace(/\{\{HEALTH_KIT_ENABLED\}\}/g, config.enableHealthKit ? "true" : "false");
     writeSource(join4(output, folder, filename), source);
   }
+  syncNotificationService(output, config);
 }
 function refreshUsageDescriptions(output, config) {
   const path = join4(output, "Info.plist");
@@ -1248,6 +1454,7 @@ async function init(options) {
     ...given
   };
   validateHealthKitBackground(config);
+  validateNotificationAttachments(config);
   if (config.renderer !== "web" && config.renderer !== "native") {
     throw new Error(`Unknown iOS renderer: ${config.renderer}. Expected web or native.`);
   }
@@ -1349,7 +1556,8 @@ ${plistArray(nativeFontFiles, 2)}
 ${nativeDependencies.join(`
 `)}` : "").replace(/\{\{NATIVE_TARGETS\}\}/g, nativeTargets.join(`
 `));
-  writeFileSync2(join4(output, "project.yml"), projectYml);
+  writeFileSync2(join4(output, "project.yml"), `include:
+${notificationServiceInclude}${projectYml}`);
   writeFileSync2(join4(output, "Craft.entitlements"), renderEntitlements(config));
   writeFileSync2(join4(output, "PrivacyInfo.xcprivacy"), renderPrivacyManifest(config));
   renderAssetCatalog(output, config);
@@ -1399,6 +1607,7 @@ async function build(options) {
     throw new Error(`No craft.config.json found in ${output}. Run 'craft ios init' first.`);
   }
   const config = JSON.parse(readFileSync2(configPath, "utf-8"));
+  validateNotificationAttachments(config);
   if (config.renderer !== undefined && config.renderer !== "web" && config.renderer !== "native") {
     throw new Error(`Unknown iOS renderer: ${config.renderer}. Expected web or native.`);
   }