@auraindustry/aurajs 0.1.1 → 0.1.5

package/src/mobile/shared/capabilities.mjs

@@ -0,0 +1,174 @@
+import { MOBILE_CAPABILITY_REPORT_SCHEMA } from '../../build-contract/constants.mjs';
+
+export const MOBILE_BUILD_TARGETS = new Set(['android', 'ios', 'mobile']);
+
+const MOBILE_UNSUPPORTED_API_RULES = Object.freeze([
+  Object.freeze({
+    api: 'aura.input.isKeyDown',
+    capability: 'keyboardInput',
+    reasonCode: 'mobile_keyboard_first_control_deferred',
+  }),
+  Object.freeze({
+    api: 'aura.input.isKeyPressed',
+    capability: 'keyboardInput',
+    reasonCode: 'mobile_keyboard_first_control_deferred',
+  }),
+  Object.freeze({
+    api: 'aura.input.isKeyReleased',
+    capability: 'keyboardInput',
+    reasonCode: 'mobile_keyboard_first_control_deferred',
+  }),
+  Object.freeze({
+    api: 'aura.input.pressed',
+    capability: 'keyboardInput',
+    reasonCode: 'mobile_keyboard_first_control_deferred',
+  }),
+  Object.freeze({
+    api: 'aura.input.justPressed',
+    capability: 'keyboardInput',
+    reasonCode: 'mobile_keyboard_first_control_deferred',
+  }),
+  Object.freeze({
+    api: 'aura.input.released',
+    capability: 'keyboardInput',
+    reasonCode: 'mobile_keyboard_first_control_deferred',
+  }),
+  Object.freeze({
+    api: 'aura.window.setCursorLocked',
+    capability: 'cursorLock',
+    reasonCode: 'mobile_cursor_lock_unsupported',
+  }),
+  Object.freeze({
+    api: 'aura.input.getMouseWheel',
+    capability: 'mouseWheel',
+    reasonCode: 'mobile_mouse_wheel_unsupported',
+  }),
+  Object.freeze({
+    api: 'aura.window.setSize',
+    capability: 'windowManagement',
+    reasonCode: 'mobile_window_management_unsupported',
+  }),
+  Object.freeze({
+    api: 'aura.window.setFullscreen',
+    capability: 'windowManagement',
+    reasonCode: 'mobile_window_management_unsupported',
+  }),
+  Object.freeze({
+    api: 'aura.window.minimize',
+    capability: 'windowManagement',
+    reasonCode: 'mobile_window_management_unsupported',
+  }),
+  Object.freeze({
+    api: 'aura.window.restore',
+    capability: 'windowManagement',
+    reasonCode: 'mobile_window_management_unsupported',
+  }),
+  Object.freeze({
+    api: 'aura.window.focus',
+    capability: 'windowManagement',
+    reasonCode: 'mobile_window_management_unsupported',
+  }),
+  Object.freeze({
+    api: 'aura.window.getSafeAreaInsets',
+    capability: 'safeArea',
+    reasonCode: 'mobile_safe_area_unavailable',
+  }),
+  Object.freeze({
+    api: 'aura.window.setOrientationLock',
+    capability: 'orientationControl',
+    reasonCode: 'mobile_orientation_control_unavailable',
+  }),
+  Object.freeze({
+    api: 'aura.input.gyro',
+    capability: 'sensor',
+    reasonCode: 'mobile_sensor_unavailable',
+  }),
+  Object.freeze({
+    api: 'aura.input.accelerometer',
+    capability: 'sensor',
+    reasonCode: 'mobile_sensor_unavailable',
+  }),
+]);
+
+const MOBILE_DEFERRED_SURFACES = Object.freeze([
+  Object.freeze({
+    surface: 'keyboardFirstControls',
+    status: 'deferred',
+    reasonCode: 'mobile_keyboard_first_control_deferred',
+  }),
+  Object.freeze({
+    surface: 'multiTouchPublicContract',
+    status: 'deferred',
+    reasonCode: null,
+  }),
+  Object.freeze({
+    surface: 'orientationControl',
+    status: 'deferred',
+    reasonCode: 'mobile_orientation_control_unavailable',
+  }),
+  Object.freeze({
+    surface: 'safeArea',
+    status: 'deferred',
+    reasonCode: 'mobile_safe_area_unavailable',
+  }),
+  Object.freeze({
+    surface: 'sensors',
+    status: 'deferred',
+    reasonCode: 'mobile_sensor_unavailable',
+  }),
+]);
+
+function normalizeRequiredApis(requiredApis) {
+  if (!Array.isArray(requiredApis)) {
+    return [];
+  }
+  return [...new Set(requiredApis
+    .filter((entry) => typeof entry === 'string')
+    .map((entry) => entry.trim())
+    .filter(Boolean))]
+    .sort((a, b) => a.localeCompare(b));
+}
+
+export function normalizeMobileBuildTarget(target) {
+  const normalized = typeof target === 'string' ? target.trim().toLowerCase() : '';
+  if (!MOBILE_BUILD_TARGETS.has(normalized)) {
+    throw new Error(`Unsupported mobile build target: ${target}`);
+  }
+  return normalized;
+}
+
+export function buildMobileCapabilityReport({ target, capabilityDeclaration } = {}) {
+  const normalizedTarget = normalizeMobileBuildTarget(target || 'mobile');
+  const requiredApis = normalizeRequiredApis(capabilityDeclaration?.requiredApis);
+  const unsupportedApis = MOBILE_UNSUPPORTED_API_RULES
+    .filter((rule) => requiredApis.includes(rule.api))
+    .map((rule) => ({
+      api: rule.api,
+      capability: rule.capability,
+      status: 'unsupported',
+      reasonCode: rule.reasonCode,
+    }));
+
+  return {
+    schema: MOBILE_CAPABILITY_REPORT_SCHEMA,
+    schemaVersion: '1.0.0',
+    buildTarget: normalizedTarget,
+    source: typeof capabilityDeclaration?.source === 'string' ? capabilityDeclaration.source : null,
+    reasonCode: unsupportedApis.length > 0
+      ? 'mobile_required_api_unsupported'
+      : 'mobile_capability_contract_ok',
+    ok: unsupportedApis.length === 0,
+    input: {
+      primaryPointer: {
+        status: 'supported',
+        reasonCode: null,
+      },
+      multiTouch: {
+        status: 'deferred',
+        reasonCode: null,
+      },
+    },
+    unsupportedApis,
+    deferredSurfaces: MOBILE_DEFERRED_SURFACES,
+  };
+}

package/src/package-integrity.mjs

@@ -72,7 +72,7 @@ function readJsonFile(path) {
   }
 }
 
-function listHashedPackageFiles(root, current = root, acc = []) {
+function listHashedPackageFiles(root, current = root, acc = [], includedPaths = null) {
   for (const entry of readdirSync(current, { withFileTypes: true })) {
     const fullPath = join(current, entry.name);
     const relativePath = normalizeRelativePath(relative(root, fullPath));
@@ -92,7 +92,7 @@ function listHashedPackageFiles(root, current = root, acc = []) {
     }
 
     if (entry.isDirectory()) {
-      listHashedPackageFiles(root, fullPath, acc);
+      listHashedPackageFiles(root, fullPath, acc, includedPaths);
       continue;
     }
 
@@ -100,6 +100,10 @@ function listHashedPackageFiles(root, current = root, acc = []) {
       continue;
     }
 
+    if (includedPaths && !includedPaths.has(relativePath)) {
+      continue;
+    }
+
     const buffer = readFileSync(fullPath);
     acc.push({
       path: relativePath,
@@ -198,8 +202,16 @@ function normalizeBuildMetadata(buildMetadata = {}) {
   };
 }
 
-function buildManifestBody({ packageRoot, projectPackage, buildMetadata = null, signer }) {
+function buildManifestBody({ packageRoot, projectPackage, buildMetadata = null, signer, includedRelativePaths = null }) {
   const resolvedPackage = projectPackage || readJsonFile(resolve(packageRoot, 'package.json'));
+  const normalizedIncludedPaths = Array.isArray(includedRelativePaths)
+    ? new Set(
+      includedRelativePaths
+        .map((entry) => normalizeRelativePath(entry))
+        .filter(Boolean)
+        .filter((entry) => entry !== PACKAGE_INTEGRITY_MANIFEST_PATH && entry !== PACKAGE_INTEGRITY_SIGNATURE_PATH),
+    )
+    : null;
   return {
     schema: PACKAGE_INTEGRITY_SCHEMA,
     package: {
@@ -219,7 +231,7 @@ function buildManifestBody({ packageRoot, projectPackage, buildMetadata = null,
       publicKeyPem: signer.publicKeyPem,
       fingerprint: signer.fingerprint,
     },
-    files: listHashedPackageFiles(packageRoot),
+    files: listHashedPackageFiles(packageRoot, packageRoot, [], normalizedIncludedPaths),
   };
 }
 
@@ -512,6 +524,7 @@ export function writeSignedPackageIntegrityArtifacts({
   signerProjectRoot = packageRoot,
   buildMetadata = null,
   projectPackage = null,
+  includedRelativePaths = null,
 } = {}) {
   const resolvedPackageRoot = resolve(packageRoot || process.cwd());
   const signer = ensureSignerKeyPair(resolve(signerProjectRoot || resolvedPackageRoot));
@@ -520,6 +533,7 @@ export function writeSignedPackageIntegrityArtifacts({
     projectPackage,
     buildMetadata,
     signer,
+    includedRelativePaths,
   });
   const signature = sign(
     null,

package/src/packs/catalog.mjs

@@ -0,0 +1,259 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const PACK_CATALOG_SCHEMA = 'aurajs.pack-catalog.v1';
+export const PROJECT_PACKS_SCHEMA = 'aurajs.project-packs.v1';
+export const PROJECT_PACKS_MANIFEST_PATH = 'aura.packs.json';
+
+const PACKS_DIR = dirname(fileURLToPath(import.meta.url));
+const CLI_PACKAGE_ROOT = resolve(PACKS_DIR, '../..');
+const REPO_ROOT = resolve(CLI_PACKAGE_ROOT, '../..');
+const WORKSPACE_PACKAGES_ROOT = resolve(REPO_ROOT, 'packages');
+const CLI_PACKAGE = JSON.parse(readFileSync(resolve(CLI_PACKAGE_ROOT, 'package.json'), 'utf8'));
+const CLI_PACKAGE_VERSION = String(CLI_PACKAGE.version || '0.1.0');
+const PUBLIC_PACK_GITHUB_REPOSITORY = 'Aura-Industry/auramaxx';
+
+function createPublicPackGithub(packDirName) {
+  return {
+    repository: PUBLIC_PACK_GITHUB_REPOSITORY,
+    ref: 'main',
+    packPath: `packs/${packDirName}`,
+  };
+}
+
+const PACK_REGISTRY = [
+  {
+    id: 'ai-starters',
+    kind: 'starter-pack',
+    title: 'AI Starters',
+    description: 'AI-first recipes, prompts, and starter overlays for AuraJS projects.',
+    packageName: '@auraindustry/aurajs-pack-ai-starters',
+    workspaceDirName: 'aurajs-pack-ai-starters',
+    surfaces: ['recipes', 'skills', 'starter-overlays'],
+    recommendedFor: ['ai', '2d', 'starter-authoring'],
+    github: createPublicPackGithub('aurajs-pack-ai-starters'),
+  },
+  {
+    id: 'assets-2d-core',
+    kind: 'asset-pack',
+    title: '2D Core Assets',
+    description: 'Optional placeholder-ready 2D palette, HUD, and audio planning assets.',
+    packageName: '@auraindustry/aurajs-pack-assets-2d-core',
+    workspaceDirName: 'aurajs-pack-assets-2d-core',
+    surfaces: ['assets', 'palettes', 'audio-planning'],
+    recommendedFor: ['2d', 'prototype', 'placeholder-art'],
+    github: createPublicPackGithub('aurajs-pack-assets-2d-core'),
+  },
+  {
+    id: 'ui-hud-2d',
+    kind: 'ui-pack',
+    title: 'UI HUD 2D',
+    description: 'Reusable 2D HUD themes, layout payloads, and widget planning files.',
+    packageName: '@auraindustry/aurajs-pack-ui-hud-2d',
+    workspaceDirName: 'aurajs-pack-ui-hud-2d',
+    surfaces: ['themes', 'layouts', 'widgets'],
+    recommendedFor: ['2d', 'hud', 'ui'],
+    github: createPublicPackGithub('aurajs-pack-ui-hud-2d'),
+  },
+  {
+    id: 'audio-2d-core',
+    kind: 'audio-pack',
+    title: 'Audio 2D Core',
+    description: 'Structured 2D scene audio defaults, bus layout, stingers, and bark planning payloads.',
+    packageName: '@auraindustry/aurajs-pack-audio-2d-core',
+    workspaceDirName: 'aurajs-pack-audio-2d-core',
+    surfaces: ['audio-config', 'barks', 'stingers'],
+    recommendedFor: ['2d', 'audio', 'scene-audio'],
+    github: createPublicPackGithub('aurajs-pack-audio-2d-core'),
+  },
+];
+
+const BUNDLE_REGISTRY = [
+  {
+    id: 'ai-2d-bundle',
+    kind: 'bundle',
+    title: 'AI 2D Bundle',
+    description: 'Recommended optional pack set for AI-assisted 2D AuraJS projects.',
+    packageName: '@auraindustry/aurajs-bundle-ai-2d',
+    workspaceDirName: 'aurajs-bundle-ai-2d',
+    memberPackIds: ['ai-starters', 'assets-2d-core', 'ui-hud-2d', 'audio-2d-core'],
+    recommendedFor: ['ai', '2d', 'flagship-prototype'],
+    github: createPublicPackGithub('aurajs-bundle-ai-2d'),
+  },
+];
+
+function toPosixPath(value) {
+  return String(value || '').split(/[/\\]+/g).filter(Boolean).join('/');
+}
+
+function normalizeRelativeFileSpec(projectRoot, targetRoot) {
+  const relativePath = relative(projectRoot, targetRoot);
+  const normalized = toPosixPath(relativePath);
+  if (!normalized || normalized === '.') {
+    return 'file:.';
+  }
+  if (normalized.startsWith('.')) {
+    return `file:${normalized}`;
+  }
+  return `file:./${normalized}`;
+}
+
+function buildPackEntry(entry) {
+  const workspacePath = resolve(WORKSPACE_PACKAGES_ROOT, entry.workspaceDirName);
+  return {
+    ...entry,
+    workspacePath,
+    workspaceAvailable: existsSync(workspacePath),
+    versionRange: `^${CLI_PACKAGE_VERSION}`,
+    github: entry.github ? { ...entry.github } : null,
+  };
+}
+
+function buildBundleEntry(entry) {
+  const workspacePath = resolve(WORKSPACE_PACKAGES_ROOT, entry.workspaceDirName);
+  return {
+    ...entry,
+    workspacePath,
+    workspaceAvailable: existsSync(workspacePath),
+    versionRange: `^${CLI_PACKAGE_VERSION}`,
+    github: entry.github ? { ...entry.github } : null,
+  };
+}
+
+export function listPackRegistry() {
+  return PACK_REGISTRY.map(buildPackEntry);
+}
+
+export function listBundleRegistry() {
+  return BUNDLE_REGISTRY.map(buildBundleEntry);
+}
+
+export function findPackEntry(id) {
+  return listPackRegistry().find((entry) => entry.id === id) || null;
+}
+
+export function findBundleEntry(id) {
+  return listBundleRegistry().find((entry) => entry.id === id) || null;
+}
+
+export function findPackOrBundleEntry(id) {
+  return findPackEntry(id) || findBundleEntry(id);
+}
+
+export function expandPackSelection(id) {
+  const pack = findPackEntry(id);
+  if (pack) {
+    return {
+      requested: pack,
+      bundles: [],
+      packs: [pack],
+    };
+  }
+  const bundle = findBundleEntry(id);
+  if (!bundle) {
+    return null;
+  }
+  const packs = bundle.memberPackIds
+    .map((memberId) => findPackEntry(memberId))
+    .filter(Boolean);
+  return {
+    requested: bundle,
+    bundles: [bundle],
+    packs,
+  };
+}
+
+export function resolvePackInstallSpec(entry, { projectRoot, workspace = false } = {}) {
+  if (workspace && projectRoot && entry.workspaceAvailable) {
+    return {
+      mode: 'workspace',
+      spec: normalizeRelativeFileSpec(projectRoot, entry.workspacePath),
+    };
+  }
+  return {
+    mode: 'package',
+    spec: entry.versionRange,
+  };
+}
+
+export function createPackCatalogReport() {
+  return {
+    schema: PACK_CATALOG_SCHEMA,
+    corePackage: CLI_PACKAGE.name,
+    coreVersion: CLI_PACKAGE_VERSION,
+    packs: listPackRegistry().map((entry) => ({
+      id: entry.id,
+      kind: entry.kind,
+      title: entry.title,
+      description: entry.description,
+      packageName: entry.packageName,
+      versionRange: entry.versionRange,
+      workspaceAvailable: entry.workspaceAvailable,
+      github: entry.github ? { ...entry.github } : null,
+      recommendedFor: [...entry.recommendedFor],
+      surfaces: [...entry.surfaces],
+    })),
+    bundles: listBundleRegistry().map((entry) => ({
+      id: entry.id,
+      kind: entry.kind,
+      title: entry.title,
+      description: entry.description,
+      packageName: entry.packageName,
+      versionRange: entry.versionRange,
+      workspaceAvailable: entry.workspaceAvailable,
+      github: entry.github ? { ...entry.github } : null,
+      recommendedFor: [...entry.recommendedFor],
+      memberPackIds: [...entry.memberPackIds],
+    })),
+  };
+}
+
+export function normalizeProjectPackManifest(value) {
+  const safe = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+  return {
+    schema: PROJECT_PACKS_SCHEMA,
+    selected: Array.isArray(safe.selected)
+      ? safe.selected
+        .filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry))
+        .map((entry) => ({
+          id: typeof entry.id === 'string' ? entry.id : null,
+          kind: typeof entry.kind === 'string' ? entry.kind : 'starter-pack',
+          sourceMode: entry.sourceMode === 'github'
+            ? 'github'
+            : entry.sourceMode === 'workspace'
+              ? 'workspace'
+              : 'package',
+        }))
+        .filter((entry) => entry.id)
+      : [],
+    packs: Array.isArray(safe.packs)
+      ? safe.packs
+        .filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry))
+        .map((entry) => ({
+          id: typeof entry.id === 'string' ? entry.id : null,
+          kind: typeof entry.kind === 'string' ? entry.kind : 'starter-pack',
+          packageName: typeof entry.packageName === 'string' ? entry.packageName : null,
+          spec: typeof entry.spec === 'string' ? entry.spec : null,
+          installMode: entry.installMode === 'workspace' ? 'workspace' : 'package',
+          sourceMode: entry.sourceMode === 'github'
+            ? 'github'
+            : entry.sourceMode === 'workspace'
+              ? 'workspace'
+              : 'package',
+          vendoredPaths: Array.isArray(entry.vendoredPaths) ? entry.vendoredPaths.map((item) => String(item)) : [],
+        }))
+        .filter((entry) => entry.id)
+      : [],
+    bundles: Array.isArray(safe.bundles)
+      ? safe.bundles
+        .filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry))
+        .map((entry) => ({
+          id: typeof entry.id === 'string' ? entry.id : null,
+          packageName: typeof entry.packageName === 'string' ? entry.packageName : null,
+          memberPackIds: Array.isArray(entry.memberPackIds) ? entry.memberPackIds.map((item) => String(item)) : [],
+        }))
+        .filter((entry) => entry.id)
+      : [],
+  };
+}

package/src/perf-benchmark-runner.mjs

@@ -77,19 +77,24 @@ function parseCliArgs(argv) {
 }
 
 function mapApplicableScenes(report, sceneThresholds = {}) {
-  const reportSceneIds = new Set((report?.scenes || []).map((scene) => scene.id));
+  const scenesById = new Map((report?.scenes || []).map((scene) => [scene.id, scene]));
   return Object.entries(sceneThresholds)
-    .filter(([sceneId]) => reportSceneIds.has(sceneId))
-    .map(([sceneId, limits]) => ({
-      id: sceneId,
-      maxAvgFrameTimeMs: limits.maxAvgFrameTimeMs,
-      maxJitterMs: limits.maxJitterMs,
-      minFps: limits.minFps,
-      maxP50FrameTimeMs: limits.maxP50FrameTimeMs,
-      maxP95FrameTimeMs: limits.maxP95FrameTimeMs,
-      maxP99FrameTimeMs: limits.maxP99FrameTimeMs,
-      maxStutterBurstCount: limits.maxStutterBurstCount,
-    }));
+    .filter(([sceneId]) => scenesById.has(sceneId))
+    .map(([sceneId, limits]) => {
+      const scene = scenesById.get(sceneId) || {};
+      return {
+        id: sceneId,
+        lane: typeof scene.lane === 'string' ? scene.lane : null,
+        surfaceTags: Array.isArray(scene.surfaceTags) ? [...scene.surfaceTags] : [],
+        maxAvgFrameTimeMs: limits.maxAvgFrameTimeMs,
+        maxJitterMs: limits.maxJitterMs,
+        minFps: limits.minFps,
+        maxP50FrameTimeMs: limits.maxP50FrameTimeMs,
+        maxP95FrameTimeMs: limits.maxP95FrameTimeMs,
+        maxP99FrameTimeMs: limits.maxP99FrameTimeMs,
+        maxStutterBurstCount: limits.maxStutterBurstCount,
+      };
+    });
 }
 
 function bucketFailures(failures) {