vibe64 0.1.21

package/node_modules/@local/vibe64-adapters/src/server/adapters/laravel/config.js

@@ -0,0 +1,54 @@
+import {
+  defaultConfigFromFields
+} from "../../configValues.js";
+import { deepFreeze } from "@local/vibe64-core/server/deepFreeze";
+import {
+  DEFAULT_NODE_PACKAGE_MANAGER
+} from "../../nodePackageManagers.js";
+import {
+  LARAVEL_DATABASE_RUNTIME_CONFIG
+} from "./constants.js";
+
+const LARAVEL_CONFIG_FIELDS = deepFreeze([
+  {
+    defaultValue: "sqlite",
+    description: "Database runtime Studio should prepare for local Laravel runs. The seed workflow chooses Laravel starter kits and modules later.",
+    id: LARAVEL_DATABASE_RUNTIME_CONFIG,
+    label: "Database runtime",
+    options: [
+      {
+        description: "Use local SQLite files for the simplest local Laravel setup.",
+        label: "SQLite",
+        value: "sqlite"
+      },
+      {
+        description: "Use a managed PostgreSQL service on the Studio runtime network.",
+        label: "PostgreSQL",
+        value: "postgres"
+      },
+      {
+        description: "Use a managed MySQL-compatible service on the Studio runtime network.",
+        label: "MySQL",
+        value: "mysql"
+      },
+      {
+        description: "Use a managed MariaDB service on the Studio runtime network.",
+        label: "MariaDB",
+        value: "mariadb"
+      }
+    ],
+    type: "select"
+  }
+]);
+
+const LARAVEL_DEFAULT_CONFIG = deepFreeze(defaultConfigFromFields(LARAVEL_CONFIG_FIELDS));
+
+function selectedLaravelPackageManager() {
+  return DEFAULT_NODE_PACKAGE_MANAGER;
+}
+
+export {
+  LARAVEL_CONFIG_FIELDS,
+  LARAVEL_DEFAULT_CONFIG,
+  selectedLaravelPackageManager
+};

package/node_modules/@local/vibe64-adapters/src/server/adapters/laravel/constants.js

@@ -0,0 +1,7 @@
+const LARAVEL_DATABASE_RUNTIME_CONFIG = "laravel_database_runtime";
+const LARAVEL_PROJECT_KNOWLEDGE_RELATIVE_PATH = ".vibe64/LARAVEL_PROJECT.md";
+
+export {
+  LARAVEL_DATABASE_RUNTIME_CONFIG,
+  LARAVEL_PROJECT_KNOWLEDGE_RELATIVE_PATH
+};

package/node_modules/@local/vibe64-adapters/src/server/adapters/laravel/currentApp.js

@@ -0,0 +1,187 @@
+import path from "node:path";
+import process from "node:process";
+
+import {
+  inspectDescribedCurrentApp
+} from "../../currentAppInspection.js";
+import {
+  createVibe64TargetScriptTerminalSpec,
+  targetScriptError
+} from "@local/studio-terminal-core/server/targetScriptTerminal";
+import {
+  detectPackageManager,
+  readPackageJson,
+  runScriptCommand
+} from "../../nodePackage.js";
+import {
+  composerDependencyNames,
+  composerProjectName,
+  composerRunCommand,
+  composerScript,
+  composerScriptNames,
+  hasComposerDependency,
+  phpArtisanCommand,
+  readComposerJson
+} from "./composerPackage.js";
+import {
+  LARAVEL_TOOLCHAIN_IMAGE
+} from "./toolchainIdentity.js";
+
+const DEFAULT_TARGET_SCRIPT_NAMES = Object.freeze([
+  "dev",
+  "test",
+  "artisan:serve",
+  "artisan:migrate",
+  "artisan:test",
+  "pint"
+]);
+
+const LARAVEL_CURRENT_APP_MARKERS = Object.freeze([
+  { id: "composerJson", label: "composer.json", relativePath: "composer.json", kind: "file" },
+  { id: "artisan", label: "artisan", relativePath: "artisan", kind: "file" },
+  { id: "bootstrapApp", label: "bootstrap/app.php", relativePath: "bootstrap/app.php", kind: "file" },
+  { id: "routesWeb", label: "routes/web.php", relativePath: "routes/web.php", kind: "file" },
+  { id: "publicIndex", label: "public/index.php", relativePath: "public/index.php", kind: "file" }
+]);
+
+const LARAVEL_PROJECT_DIRECTORIES = Object.freeze([
+  { id: "app", label: "app", relativePath: "app" },
+  { id: "bootstrap", label: "bootstrap", relativePath: "bootstrap" },
+  { id: "config", label: "config", relativePath: "config" },
+  { id: "database", label: "database", relativePath: "database" },
+  { id: "public", label: "public", relativePath: "public" },
+  { id: "resources", label: "resources", relativePath: "resources" },
+  { id: "routes", label: "routes", relativePath: "routes" },
+  { id: "tests", label: "tests", relativePath: "tests" }
+]);
+
+function laravelMarkersReady(markers = []) {
+  const existing = new Set(markers.filter((marker) => marker.exists).map((marker) => marker.id));
+  return existing.has("composerJson") && existing.has("artisan") && existing.has("bootstrapApp");
+}
+
+function composerScriptEntries(composerJson = {}) {
+  return composerScriptNames(composerJson).map((name) => ({
+    command: composerRunCommand(name),
+    id: `adapter:${name}`,
+    label: name,
+    name,
+    source: "adapter",
+    starredByDefault: DEFAULT_TARGET_SCRIPT_NAMES.includes(name)
+  }));
+}
+
+function syntheticLaravelScripts(composerJson = {}) {
+  const existing = new Set(composerScriptNames(composerJson));
+  return [
+    ["artisan:serve", phpArtisanCommand(["serve", "--host=0.0.0.0"])],
+    ["artisan:migrate", phpArtisanCommand(["migrate"])],
+    ["artisan:test", phpArtisanCommand(["test"])],
+    ["artisan:route-list", phpArtisanCommand(["route:list"])],
+    ["pint", "./vendor/bin/pint"]
+  ]
+    .filter(([name]) => !existing.has(name))
+    .map(([name, command]) => ({
+      command,
+      id: `adapter:${name}`,
+      label: name,
+      name,
+      source: "adapter",
+      starredByDefault: DEFAULT_TARGET_SCRIPT_NAMES.includes(name)
+    }));
+}
+
+async function inspectConfig(appRoot) {
+  const composerJson = await readComposerJson(appRoot) || {};
+  const packageJson = await readPackageJson(appRoot) || {};
+  const packageManager = await detectPackageManager(appRoot, packageJson);
+  return {
+    composerName: composerProjectName(composerJson),
+    composerScripts: composerScriptNames(composerJson),
+    dependencies: composerDependencyNames(composerJson),
+    devScript: composerScript(composerJson, "dev"),
+    laravelDependency: hasComposerDependency(composerJson, "laravel/framework"),
+    nodePackageManager: packageManager,
+    packageScripts: Object.keys(packageJson.scripts || {}).sort((left, right) => left.localeCompare(right)),
+    testScript: composerScript(composerJson, "test")
+  };
+}
+
+async function inspectLaravelCurrentApp(targetRoot, {
+  includeGit = true
+} = {}) {
+  return inspectDescribedCurrentApp(targetRoot, {
+    adapter: "laravel",
+    appPath: "/",
+    config: inspectConfig,
+    directories: LARAVEL_PROJECT_DIRECTORIES,
+    includeGit,
+    localPackages: async (appRoot) => {
+      const composerJson = await readComposerJson(appRoot) || {};
+      return {
+        appPackageName: composerProjectName(composerJson),
+        packages: []
+      };
+    },
+    markers: LARAVEL_CURRENT_APP_MARKERS,
+    ready: laravelMarkersReady
+  });
+}
+
+async function readLaravelTargetScripts(appRoot) {
+  const composerJson = await readComposerJson(appRoot);
+  if (!composerJson) {
+    return targetScriptError("composer_json_missing", `Cannot find ${path.join(appRoot, "composer.json")}.`, {
+      scripts: []
+    });
+  }
+  const scripts = [
+    ...composerScriptEntries(composerJson),
+    ...syntheticLaravelScripts(composerJson)
+  ].sort((left, right) => left.name.localeCompare(right.name));
+  return {
+    composerJson,
+    ok: true,
+    scripts
+  };
+}
+
+async function inspectLaravelTargetScripts(appRoot) {
+  const result = await readLaravelTargetScripts(path.resolve(appRoot || process.cwd()));
+  if (result.ok === false) {
+    return result;
+  }
+  return {
+    ok: true,
+    scriptCount: result.scripts.length,
+    scripts: result.scripts
+  };
+}
+
+async function createLaravelTargetScriptTerminalSpec(targetRoot, input = {}) {
+  const normalizedTargetRoot = path.resolve(targetRoot || process.cwd());
+  const scriptsResult = await readLaravelTargetScripts(normalizedTargetRoot);
+  if (scriptsResult.ok === false) {
+    return scriptsResult;
+  }
+  return createVibe64TargetScriptTerminalSpec({
+    adapterId: "laravel",
+    image: LARAVEL_TOOLCHAIN_IMAGE,
+    input,
+    scripts: scriptsResult.scripts,
+    targetRoot: normalizedTargetRoot
+  });
+}
+
+function laravelFrontendBuildCommand(packageManagerName = "npm") {
+  return runScriptCommand(packageManagerName, "build");
+}
+
+export {
+  DEFAULT_TARGET_SCRIPT_NAMES,
+  createLaravelTargetScriptTerminalSpec,
+  inspectLaravelCurrentApp,
+  inspectLaravelTargetScripts,
+  laravelFrontendBuildCommand,
+  laravelMarkersReady
+};

package/node_modules/@local/vibe64-adapters/src/server/adapters/laravel/databaseRuntime.js

@@ -0,0 +1,237 @@
+import {
+  createRuntimeContainerRepair,
+  runtimeContainerName
+} from "@local/studio-terminal-core/server/runtimeContainers";
+import {
+  createManagedDatabaseRuntimeContainer,
+  managedDatabaseConnection,
+  managedDatabaseNameFromTargetRoot
+} from "@local/studio-terminal-core/server/managedDatabases";
+import {
+  selectedConfigValue
+} from "../../configValues.js";
+import {
+  envFileWriteScript,
+  envValuesFromLines
+} from "../../adapterHelpers/setupEnvFiles.js";
+import {
+  LARAVEL_DATABASE_RUNTIME_CONFIG
+} from "./constants.js";
+
+const LARAVEL_DATABASE_RUNTIMES = new Set(["sqlite", "postgres", "mysql", "mariadb"]);
+const LARAVEL_DATABASE_ENV_KEYS = Object.freeze([
+  "DB_CONNECTION",
+  "DB_HOST",
+  "DB_PORT",
+  "DB_DATABASE",
+  "DB_USERNAME",
+  "DB_PASSWORD"
+]);
+const LARAVEL_POSTGRES_HOST = "laravel-postgres";
+const LARAVEL_POSTGRES_HOST_PORT = "15433";
+const LARAVEL_POSTGRES_PASSWORD = "laravel_password";
+const LARAVEL_POSTGRES_USER = "laravel";
+const LARAVEL_MYSQL_HOST = "laravel-mysql";
+const LARAVEL_MYSQL_HOST_PORT = "13308";
+const LARAVEL_MYSQL_ROOT_PASSWORD = "laravel_root_password";
+const LARAVEL_MARIADB_HOST = "laravel-mariadb";
+const LARAVEL_MARIADB_HOST_PORT = "13309";
+const LARAVEL_MARIADB_ROOT_PASSWORD = "laravel_root_password";
+
+function selectedLaravelDatabaseRuntime(config = {}) {
+  return selectedConfigValue(config, LARAVEL_DATABASE_RUNTIME_CONFIG, LARAVEL_DATABASE_RUNTIMES, "sqlite");
+}
+
+function laravelDatabaseNameFromTargetRoot(targetRoot = "") {
+  return managedDatabaseNameFromTargetRoot(targetRoot, {
+    fallback: "laravel_app"
+  });
+}
+
+function laravelDatabaseConnection(runtime = "sqlite", targetRoot = "") {
+  if (runtime === "postgres") {
+    return managedDatabaseConnection({
+      adapterId: "laravel",
+      databaseNameFallback: "laravel_app",
+      host: LARAVEL_POSTGRES_HOST,
+      password: LARAVEL_POSTGRES_PASSWORD,
+      runtime,
+      targetRoot,
+      username: LARAVEL_POSTGRES_USER
+    });
+  }
+  if (runtime === "mysql") {
+    return managedDatabaseConnection({
+      adapterId: "laravel",
+      databaseNameFallback: "laravel_app",
+      host: LARAVEL_MYSQL_HOST,
+      rootPassword: LARAVEL_MYSQL_ROOT_PASSWORD,
+      runtime,
+      targetRoot
+    });
+  }
+  if (runtime === "mariadb") {
+    return managedDatabaseConnection({
+      adapterId: "laravel",
+      databaseNameFallback: "laravel_app",
+      host: LARAVEL_MARIADB_HOST,
+      rootPassword: LARAVEL_MARIADB_ROOT_PASSWORD,
+      runtime,
+      targetRoot
+    });
+  }
+  return managedDatabaseConnection({
+    adapterId: "laravel",
+    runtime: "sqlite",
+    targetRoot
+  });
+}
+
+function createLaravelRuntimeContainers({
+  config = {},
+  targetRoot = ""
+} = {}) {
+  const runtime = selectedLaravelDatabaseRuntime(config);
+  if (runtime === "postgres") {
+    return [
+      createManagedDatabaseRuntimeContainer({
+        adapterId: "laravel",
+        checkId: "laravel-postgres",
+        databaseNameFallback: "laravel_app",
+        host: LARAVEL_POSTGRES_HOST,
+        hostPort: LARAVEL_POSTGRES_HOST_PORT,
+        label: "Laravel PostgreSQL",
+        password: LARAVEL_POSTGRES_PASSWORD,
+        runtime,
+        targetRoot,
+        username: LARAVEL_POSTGRES_USER
+      })
+    ];
+  }
+  if (runtime === "mysql") {
+    return [
+      createManagedDatabaseRuntimeContainer({
+        adapterId: "laravel",
+        checkId: "laravel-mysql",
+        databaseNameFallback: "laravel_app",
+        host: LARAVEL_MYSQL_HOST,
+        hostPort: LARAVEL_MYSQL_HOST_PORT,
+        label: "Laravel MySQL",
+        rootPassword: LARAVEL_MYSQL_ROOT_PASSWORD,
+        runtime,
+        targetRoot
+      })
+    ];
+  }
+  if (runtime === "mariadb") {
+    return [
+      createManagedDatabaseRuntimeContainer({
+        adapterId: "laravel",
+        checkId: "laravel-mariadb",
+        databaseNameFallback: "laravel_app",
+        host: LARAVEL_MARIADB_HOST,
+        hostPort: LARAVEL_MARIADB_HOST_PORT,
+        label: "Laravel MariaDB",
+        rootPassword: LARAVEL_MARIADB_ROOT_PASSWORD,
+        runtime,
+        targetRoot
+      })
+    ];
+  }
+  return [];
+}
+
+function laravelRuntimeContainerName({
+  config = {},
+  targetRoot = ""
+} = {}) {
+  const runtime = selectedLaravelDatabaseRuntime(config);
+  if (!["postgres", "mysql", "mariadb"].includes(runtime)) {
+    return "";
+  }
+  return runtimeContainerName({
+    adapterId: "laravel",
+    containerId: `laravel-${runtime}`,
+    targetRoot
+  });
+}
+
+function startLaravelRuntimeRepair({
+  config = {},
+  targetRoot = ""
+} = {}) {
+  const [container] = createLaravelRuntimeContainers({
+    config,
+    targetRoot
+  });
+  return container
+    ? createRuntimeContainerRepair(container, {
+        adapterId: "laravel",
+        targetRoot
+      })
+    : null;
+}
+
+function laravelDatabaseEnvLines({
+  config = {},
+  targetRoot = ""
+} = {}) {
+  const runtime = selectedLaravelDatabaseRuntime(config);
+  if (runtime === "sqlite") {
+    return [
+      "DB_CONNECTION=sqlite"
+    ];
+  }
+  const connection = laravelDatabaseConnection(runtime, targetRoot);
+  const driver = runtime === "postgres" ? "pgsql" : runtime;
+  return [
+    `DB_CONNECTION=${driver}`,
+    `DB_HOST=${connection.host}`,
+    `DB_PORT=${connection.port}`,
+    `DB_DATABASE=${connection.database}`,
+    `DB_USERNAME=${connection.username}`,
+    `DB_PASSWORD=${connection.password}`
+  ];
+}
+
+function laravelDatabaseEnvWriteScript({
+  config = {},
+  targetRoot = ""
+} = {}) {
+  const runtime = selectedLaravelDatabaseRuntime(config);
+  const lines = laravelDatabaseEnvLines({
+    config,
+    targetRoot
+  });
+  return [
+    envFileWriteScript({
+      relativePath: ".env",
+      removeKeys: LARAVEL_DATABASE_ENV_KEYS,
+      replaceExisting: true,
+      values: envValuesFromLines(lines)
+    }),
+    ...(runtime === "sqlite" ? [
+      "mkdir -p database",
+      "touch database/database.sqlite"
+    ] : []),
+    "echo 'Wrote Laravel database settings for Vibe64-managed runtime.'"
+  ].join("\n");
+}
+
+export {
+  LARAVEL_DATABASE_RUNTIMES,
+  LARAVEL_MARIADB_HOST,
+  LARAVEL_MARIADB_HOST_PORT,
+  LARAVEL_MYSQL_HOST,
+  LARAVEL_MYSQL_HOST_PORT,
+  LARAVEL_POSTGRES_HOST,
+  LARAVEL_POSTGRES_HOST_PORT,
+  createLaravelRuntimeContainers,
+  laravelDatabaseConnection,
+  laravelDatabaseEnvLines,
+  laravelDatabaseEnvWriteScript,
+  laravelDatabaseNameFromTargetRoot,
+  laravelRuntimeContainerName,
+  selectedLaravelDatabaseRuntime,
+  startLaravelRuntimeRepair
+};

package/node_modules/@local/vibe64-adapters/src/server/adapters/laravel/index.js

@@ -0,0 +1,60 @@
+import {
+  LARAVEL_CONFIG_FIELDS,
+  LARAVEL_MARKERS,
+  LARAVEL_PROMPT_PACK_ROOT,
+  LARAVEL_PREPARE_WORKTREE_SCRIPT_PATH,
+  LaravelTargetAdapter
+} from "./adapter.js";
+import {
+  deepFreeze
+} from "@local/vibe64-core/server/deepFreeze";
+import {
+  VIBE64_WORKFLOW_COMMANDS,
+  createVibe64WorkflowCommandTerminalSpec
+} from "../../workflowAdapter.js";
+import {
+  createLaravelLaunchDescriptor,
+  createLaravelLaunchTargetTerminalSpec,
+  listLaravelLaunchTargets
+} from "./launchTargets.js";
+
+export {
+  DEFAULT_TARGET_SCRIPT_NAMES,
+  createLaravelTargetScriptTerminalSpec,
+  inspectLaravelCurrentApp,
+  inspectLaravelTargetScripts
+} from "./currentApp.js";
+export {
+  LARAVEL_DATABASE_RUNTIME_CONFIG,
+  LARAVEL_PROJECT_KNOWLEDGE_RELATIVE_PATH
+} from "./constants.js";
+
+const LARAVEL_VIBE64_COMMANDS = deepFreeze(VIBE64_WORKFLOW_COMMANDS);
+const createLaravelVibe64CommandTerminalSpec = createVibe64WorkflowCommandTerminalSpec;
+
+function createLaravelTargetAdapter({
+  commandTerminalSpecFactory = null,
+  launchTargetTerminalSpecFactory = createLaravelLaunchTargetTerminalSpec,
+  launchTargets = listLaravelLaunchTargets
+} = {}) {
+  return new LaravelTargetAdapter({
+    commandTerminalSpecFactory,
+    launchTargetTerminalSpecFactory,
+    launchTargets,
+    commands: LARAVEL_VIBE64_COMMANDS
+  });
+}
+
+export {
+  createLaravelVibe64CommandTerminalSpec,
+  createLaravelLaunchDescriptor,
+  createLaravelLaunchTargetTerminalSpec,
+  createLaravelTargetAdapter,
+  listLaravelLaunchTargets,
+  LARAVEL_VIBE64_COMMANDS,
+  LARAVEL_CONFIG_FIELDS,
+  LARAVEL_MARKERS,
+  LARAVEL_PROMPT_PACK_ROOT,
+  LARAVEL_PREPARE_WORKTREE_SCRIPT_PATH,
+  LaravelTargetAdapter
+};

package/node_modules/@local/vibe64-adapters/src/server/adapters/laravel/launchTargets.js

@@ -0,0 +1,115 @@
+import {
+  createVibe64WebLaunchTargetTerminalSpec
+} from "@local/studio-terminal-core/server/launchTargetTerminal";
+import {
+  detectPackageManager,
+  packageScript,
+  readPackageJson,
+  runScriptCommand
+} from "../../nodePackage.js";
+import {
+  composerScript,
+  readComposerJson
+} from "./composerPackage.js";
+import {
+  LARAVEL_TOOLCHAIN_IMAGE
+} from "./toolchainIdentity.js";
+
+function laravelLaunchTarget(id, label) {
+  return {
+    id,
+    label
+  };
+}
+
+async function listLaravelLaunchTargets({
+  session = {}
+} = {}) {
+  const worktreePath = String(session.metadata?.worktree_path || "").trim();
+  if (!worktreePath || !await readComposerJson(worktreePath)) {
+    return [];
+  }
+  return [
+    laravelLaunchTarget("built", "Build assets and serve Laravel"),
+    laravelLaunchTarget("serve", "Serve Laravel app")
+  ];
+}
+
+async function createLaravelLaunchDescriptor({
+  mode = "built",
+  port,
+  worktreePath = ""
+} = {}) {
+  const [composerJson, packageJson] = await Promise.all([
+    readComposerJson(worktreePath),
+    readPackageJson(worktreePath)
+  ]);
+  const packageManager = await detectPackageManager(worktreePath, packageJson || {});
+  const hasBuildScript = packageScript(packageJson || {}, "build");
+  const buildCommand = hasBuildScript ? runScriptCommand(packageManager.name, "build") : "";
+  const hasServeScript = Boolean(composerScript(composerJson || {}, "serve"));
+  const serverCommand = hasServeScript
+    ? `composer run serve -- --host=0.0.0.0 --port ${port}`
+    : `php artisan serve --host=0.0.0.0 --port ${port}`;
+
+  return {
+    commands: [
+      mode === "built" && buildCommand
+        ? {
+            command: buildCommand,
+            label: "Building Laravel frontend assets.",
+            networkEnv: false
+          }
+        : null,
+      {
+        command: serverCommand,
+        label: "Starting Laravel application server.",
+        networkEnv: true
+      }
+    ].filter(Boolean),
+    metadata: {
+      buildCommand: mode === "built" ? buildCommand : "",
+      commandSource: hasServeScript ? "composer" : "artisan",
+      mode,
+      packageManager: packageManager.name,
+      serverCommand
+    },
+    urlPath: "/"
+  };
+}
+
+function createLaravelLaunchTargetTerminalSpec({
+  context = {},
+  launchTargetId = "",
+  session = {},
+  targetRoot = ""
+} = {}) {
+  if (!["built", "serve"].includes(launchTargetId)) {
+    return {
+      ok: false,
+      message: `Unknown Laravel launch target: ${launchTargetId || "(empty)"}.`
+    };
+  }
+  const launchTargetRoot = targetRoot || session.targetRoot || "";
+  return createVibe64WebLaunchTargetTerminalSpec({
+    adapterId: "laravel",
+    image: LARAVEL_TOOLCHAIN_IMAGE,
+    launchTarget: context.launchTarget || laravelLaunchTarget(launchTargetId, launchTargetId),
+    preferredPort: 8000,
+    resolveLaunch: ({ port, worktreePath }) => createLaravelLaunchDescriptor({
+      config: context.config || session.config || {},
+      mode: launchTargetId,
+      port,
+      targetRoot: launchTargetRoot,
+      worktreePath
+    }),
+    session,
+    targetRoot: launchTargetRoot
+  });
+}
+
+export {
+  createLaravelLaunchDescriptor,
+  createLaravelLaunchTargetTerminalSpec,
+  listLaravelLaunchTargets
+};

package/node_modules/@local/vibe64-adapters/src/server/adapters/laravel/manifest.js

@@ -0,0 +1,41 @@
+import {
+  deepFreeze
+} from "@local/vibe64-core/server/deepFreeze";
+import {
+  VIBE64_APPLICATION_TYPE_WEB
+} from "../../applicationTypes.js";
+import {
+  createLaravelTargetAdapter
+} from "./index.js";
+
+const LARAVEL_ADAPTER_MANIFEST = deepFreeze({
+  applicationTypes: [
+    {
+      explanation: "Full-stack PHP web applications and API-backed products using Laravel conventions, Composer, Artisan, Eloquent, and Vite.",
+      id: VIBE64_APPLICATION_TYPE_WEB,
+      priority: 70
+    }
+  ],
+  bestFor: "Full-stack PHP products, admin systems, API backends, CRUD-heavy business apps, and Laravel teams that want conventional framework structure.",
+  createAdapter: createLaravelTargetAdapter,
+  description: "Laravel is a PHP web application framework with Composer, Artisan, Eloquent, Blade, Vite, and official starter kits. The adapter understands Laravel setup, PHP toolchains, database runtime choices, starter authentication/team options, Composer scripts, and Artisan launch commands.",
+  enabled: true,
+  id: "laravel",
+  label: "Laravel",
+  outcome: "Studio can seed or inspect a Laravel app, configure SQLite, PostgreSQL, MySQL, or MariaDB, select official starter kits, authentication/team options, and test framework, then drive Codex with Laravel-specific prompts.",
+  projectUrl: "https://laravel.com",
+  projectUrlLabel: "Open Laravel project",
+  summary: "The mainstream PHP framework for full-stack web applications and API backends.",
+  techStack: [
+    "PHP",
+    "Laravel",
+    "Composer",
+    "Artisan",
+    "Eloquent",
+    "Vite"
+  ]
+});
+
+export {
+  LARAVEL_ADAPTER_MANIFEST
+};