@ykdz/template 0.0.41 → 0.1.0-experimental.0

package/node_modules/@ykdz/preset-vike-app/native/scripts/check-standalone-deployment.ts

@@ -0,0 +1,570 @@
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+const repositoryRoot = process.cwd();
+const rootManifest: { readonly engines: { readonly node: string } } =
+  JSON.parse(await readFile(path.join(repositoryRoot, "package.json"), "utf8"));
+const applicationPackageName = "@ykdz/reference-vike-web";
+const buildArguments = Object.entries({
+  NODE_VERSION: rootManifest.engines.node,
+  APPLICATION_PACKAGE_NAME: applicationPackageName,
+  APPLICATION_PACKAGE_PATH: "references/vike-web",
+  DATABASE_PACKAGE_NAME: "@ykdz/reference-vike-db",
+  MIGRATION_PACKAGE_NAME: "@ykdz/reference-vike-migrations",
+}).flatMap(([name, value]) => ["--build-arg", `${name}=${value}`]);
+const uniqueId = `${process.pid}-${Date.now()}`;
+const standaloneImage = `vike-deployment-check-standalone:${uniqueId}`;
+const runtimeImage = `vike-deployment-check-runtime:${uniqueId}`;
+const network = `vike-deployment-check-${uniqueId}`;
+const containers = {
+  standalone: `vike-deployment-check-standalone-${uniqueId}`,
+  preparation: `vike-deployment-check-preparation-${uniqueId}`,
+  runtime: `vike-deployment-check-runtime-${uniqueId}`,
+  unprepared: `vike-deployment-check-unprepared-${uniqueId}`,
+} as const;
+const volumes = {
+  standalone: `vike-deployment-check-standalone-${uniqueId}`,
+  prepared: `vike-deployment-check-prepared-${uniqueId}`,
+  unprepared: `vike-deployment-check-unprepared-${uniqueId}`,
+} as const;
+const abortController = new AbortController();
+const forwardedSignals = ["SIGINT", "SIGTERM"] as const;
+const signalHandlers = new Map<NodeJS.Signals, () => void>();
+const defaultReadinessTimeoutMs = 60_000;
+
+interface CommandResult {
+  readonly stderr: string;
+  readonly stdout: string;
+}
+
+interface CommandOptions {
+  readonly cwd?: string;
+  readonly env?: NodeJS.ProcessEnv;
+  readonly signal?: AbortSignal;
+  readonly timeout: number;
+}
+
+type DeploymentMode =
+  | "standalone"
+  | "external-preparation"
+  | "runtime"
+  | "fresh-runtime";
+
+async function deploymentPhase<T>(
+  mode: DeploymentMode,
+  phase: string,
+  operation: () => Promise<T>,
+): Promise<T> {
+  try {
+    return await operation();
+  } catch (error: unknown) {
+    throw new Error(`Deployment mode ${mode} failed during ${phase}.`, {
+      cause: error,
+    });
+  }
+}
+
+function commandDisplay(command: string, args: readonly string[]): string {
+  return [command, ...args].map((part) => JSON.stringify(part)).join(" ");
+}
+
+function runCommand(
+  command: string,
+  args: readonly string[],
+  options: CommandOptions,
+): Promise<CommandResult> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      signal: options.signal,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stderr = "";
+    let stdout = "";
+    let timedOut = false;
+    let settled = false;
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk: string) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk: string) => {
+      stderr += chunk;
+    });
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, options.timeout);
+    const finish = (error?: Error): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      if (error === undefined) {
+        resolve({ stderr, stdout });
+      } else {
+        reject(Object.assign(error, { stderr, stdout }));
+      }
+    };
+    child.once("error", (error) => finish(error));
+    child.once("close", (code, signal) => {
+      if (code === 0 && !timedOut) {
+        finish();
+        return;
+      }
+      finish(
+        Object.assign(
+          new Error(
+            `${commandDisplay(command, args)} ${
+              timedOut
+                ? `timed out after ${options.timeout}ms`
+                : `exited with code ${String(code)}${signal === null ? "" : ` from ${signal}`}`
+            }\nstdout:\n${stdout}\nstderr:\n${stderr}`,
+          ),
+          { code, signal },
+        ),
+      );
+    });
+  });
+}
+
+function readinessTimeoutMs(): number {
+  const configured = process.env.STANDALONE_DEPLOYMENT_READINESS_TIMEOUT_MS;
+  if (configured === undefined) {
+    return defaultReadinessTimeoutMs;
+  }
+
+  const timeout = Number(configured);
+  if (!Number.isSafeInteger(timeout) || timeout <= 0) {
+    throw new Error(
+      "STANDALONE_DEPLOYMENT_READINESS_TIMEOUT_MS must be a positive integer",
+    );
+  }
+  return timeout;
+}
+
+async function dockerWithTimeout(
+  timeout: number,
+  ...args: string[]
+): Promise<string> {
+  const { stdout } = await runCommand("docker", args, {
+    cwd: repositoryRoot,
+    signal: abortController.signal,
+    timeout,
+  });
+  return stdout.trim();
+}
+
+async function docker(...args: string[]): Promise<string> {
+  return dockerWithTimeout(600_000, ...args);
+}
+
+async function cleanup(): Promise<void> {
+  const cleanupCommands = [
+    ...Object.values(containers).map((name) => ["rm", "--force", name]),
+    ...Object.values(volumes).map((name) => ["volume", "rm", "--force", name]),
+    ["network", "rm", network],
+    ["image", "rm", "--force", runtimeImage],
+    ["image", "rm", "--force", standaloneImage],
+  ];
+
+  for (const args of cleanupCommands) {
+    try {
+      await runCommand("docker", args, {
+        cwd: repositoryRoot,
+        timeout: 30_000,
+      });
+    } catch {
+      // A resource may not have been created yet.
+    }
+  }
+}
+
+async function containerLogs(container: string): Promise<string> {
+  try {
+    const { stderr, stdout } = await runCommand("docker", ["logs", container], {
+      cwd: repositoryRoot,
+      signal: AbortSignal.timeout(10_000),
+      timeout: 10_000,
+    });
+    return [stdout.trim(), stderr.trim()].filter(Boolean).join("\n");
+  } catch (error) {
+    return `Container logs unavailable: ${String(error)}`;
+  }
+}
+
+async function deploymentLogs(): Promise<string> {
+  const logs = await Promise.all(
+    Object.entries(containers).map(
+      async ([phase, container]) =>
+        `${phase} container logs:\n${await containerLogs(container)}`,
+    ),
+  );
+  return logs.join("\n");
+}
+
+async function dockerHostGatewayAddress(): Promise<string | undefined> {
+  try {
+    const routes = await readFile("/proc/net/route", "utf8");
+    for (const line of routes.split("\n").slice(1)) {
+      const [, destination, gateway] = line.trim().split(/\s+/u);
+      if (
+        destination !== "00000000" ||
+        gateway === undefined ||
+        gateway === "00000000"
+      ) {
+        continue;
+      }
+      const octets = gateway.match(/../gu)?.reverse();
+      if (octets === undefined) return undefined;
+      return octets
+        .map((octet) => String(Number.parseInt(octet, 16)))
+        .join(".");
+    }
+  } catch {
+    // /proc/net/route is Linux-specific. Local Docker-on-host runs still use
+    // the loopback candidate below.
+  }
+  return undefined;
+}
+
+async function publishedBaseUrls(
+  container: string,
+): Promise<readonly string[]> {
+  const portOutput = await dockerWithTimeout(
+    10_000,
+    "port",
+    container,
+    "3000/tcp",
+  );
+  const match = /:(\d+)$/u.exec(portOutput.split("\n")[0] ?? "");
+  if (!match?.[1]) {
+    throw new Error(
+      `Could not determine the published web port: ${portOutput}`,
+    );
+  }
+  const gateway = await dockerHostGatewayAddress();
+  return [
+    `http://127.0.0.1:${match[1]}`,
+    gateway === undefined ? undefined : `http://${gateway}:${match[1]}`,
+  ].filter((candidate): candidate is string => candidate !== undefined);
+}
+
+async function waitForReady(
+  phase: "Standalone" | "Runtime",
+  container: string,
+  baseUrls: readonly string[],
+): Promise<string> {
+  const timeout = readinessTimeoutMs();
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    for (const baseUrl of baseUrls) {
+      try {
+        const response = await fetch(baseUrl, {
+          signal: AbortSignal.timeout(2_000),
+        });
+        if (response.ok) {
+          return baseUrl;
+        }
+      } catch {
+        // The container may still be starting the server, or this candidate may
+        // not be reachable from the current Docker execution topology.
+      }
+    }
+
+    const running = await dockerWithTimeout(
+      5_000,
+      "inspect",
+      "--format={{.State.Running}}",
+      container,
+    );
+    if (running !== "true") {
+      throw new Error(
+        `${phase} container exited before readiness.\n${await containerLogs(container)}`,
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+
+  throw new Error(
+    `${phase} container was not ready at ${baseUrls.join(", ")} within ${timeout}ms.\n${await containerLogs(container)}`,
+  );
+}
+
+async function assertProcessIdentity(
+  phase: "Standalone" | "Runtime",
+  container: string,
+): Promise<void> {
+  await docker(
+    "exec",
+    container,
+    "node",
+    "--input-type=module",
+    "--eval",
+    `import { statSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
+const expectedIdentity = 1001;
+if (process.getuid() !== expectedIdentity || process.getgid() !== expectedIdentity) {
+  throw new Error(\`${phase} process identity must be 1001:1001, received \${process.getuid()}:\${process.getgid()}\`);
+}
+const databaseStat = statSync(process.env.DATABASE_FILE);
+if (databaseStat.uid !== expectedIdentity || databaseStat.gid !== expectedIdentity) {
+  throw new Error(\`Database ownership must be 1001:1001, received \${databaseStat.uid}:\${databaseStat.gid}\`);
+}`,
+  );
+}
+
+async function assertEmptyDatabase(container: string): Promise<void> {
+  await docker(
+    "exec",
+    container,
+    "node",
+    "--input-type=module",
+    "--eval",
+    `import { DatabaseSync } from "node:sqlite";
+const db = new DatabaseSync(process.env.DATABASE_FILE);
+const row = db.prepare("select count(*) as count from todos").get();
+if (row.count !== 0) throw new Error(\`Fresh deployment must contain zero TODOs, received \${row.count}\`);`,
+  );
+}
+
+async function runPlaywright(baseUrl: string): Promise<void> {
+  await runCommand(
+    "pnpm",
+    ["--filter", applicationPackageName, "run", "test:e2e"],
+    {
+      cwd: repositoryRoot,
+      env: {
+        ...process.env,
+        PLAYWRIGHT_EXTERNAL_BASE_URL: baseUrl,
+      },
+      signal: abortController.signal,
+      timeout: 120_000,
+    },
+  );
+}
+
+async function runStartedDeployment(
+  mode: "standalone" | "runtime",
+  readinessLabel: "Standalone" | "Runtime",
+  container: string,
+  volume: string,
+  image: string,
+): Promise<void> {
+  await deploymentPhase(mode, "start", async () =>
+    docker(
+      "run",
+      "--detach",
+      "--name",
+      container,
+      "--network",
+      network,
+      "--publish",
+      "0.0.0.0::3000",
+      "--volume",
+      `${volume}:/data`,
+      image,
+    ),
+  );
+  const baseUrls = await deploymentPhase(mode, "start", async () =>
+    publishedBaseUrls(container),
+  );
+  const baseUrl = await deploymentPhase(mode, "readiness", async () =>
+    waitForReady(readinessLabel, container, baseUrls),
+  );
+  await deploymentPhase(mode, "identity", async () =>
+    assertProcessIdentity(readinessLabel, container),
+  );
+  await deploymentPhase(mode, "empty-database", async () =>
+    assertEmptyDatabase(container),
+  );
+  await deploymentPhase(mode, "playwright", async () => runPlaywright(baseUrl));
+}
+
+async function assertUnpreparedRuntimeFails(): Promise<void> {
+  await dockerWithTimeout(
+    30_000,
+    "run",
+    "--detach",
+    "--name",
+    containers.unprepared,
+    "--network",
+    network,
+    "--publish",
+    "0.0.0.0::3000",
+    "--volume",
+    `${volumes.unprepared}:/data`,
+    runtimeImage,
+  );
+  const baseUrls = await publishedBaseUrls(containers.unprepared);
+  const deadline = Date.now() + 30_000;
+
+  while (Date.now() < deadline) {
+    const statePromise = dockerWithTimeout(
+      5_000,
+      "inspect",
+      "--format={{.State.Status}}:{{.State.ExitCode}}",
+      containers.unprepared,
+    ).then(
+      (state) => ({ state }),
+      (error: unknown) => ({ error }),
+    );
+    const probes = await Promise.all(
+      baseUrls.map((baseUrl) =>
+        fetch(baseUrl, {
+          signal: AbortSignal.timeout(500),
+        }).then(
+          (response) => ({ baseUrl, response }),
+          () => ({ baseUrl, response: undefined }),
+        ),
+      ),
+    );
+
+    const servedProbe = probes.find((probe) => probe.response !== undefined);
+    if (servedProbe?.response !== undefined) {
+      throw new Error(
+        `Unprepared runtime served HTTP ${servedProbe.response.status} at ${servedProbe.baseUrl} before exiting.`,
+      );
+    }
+
+    const stateResult = await statePromise;
+    if ("error" in stateResult) {
+      throw stateResult.error;
+    }
+    const match =
+      /^(created|running|paused|restarting|removing|exited|dead):(\d+)$/u.exec(
+        stateResult.state,
+      );
+    if (match?.[1] === "exited") {
+      const exitCode = Number(match[2]);
+      const logs = await containerLogs(containers.unprepared);
+      if (exitCode === 0) {
+        throw new Error(
+          `Unprepared runtime exited successfully instead of rejecting startup.\n${logs}`,
+        );
+      }
+      if (!logs.includes("DATABASE_NOT_READY")) {
+        throw new Error(
+          `Unprepared runtime did not report database readiness failure.\n${logs}`,
+        );
+      }
+      return;
+    }
+    if (match === null || match[1] === "dead") {
+      throw new Error(
+        `Unprepared runtime entered unexpected state ${stateResult.state}.`,
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+
+  throw new Error("Unprepared runtime did not exit within 30000ms");
+}
+
+for (const signal of forwardedSignals) {
+  const handler = (): void => {
+    abortController.abort(new Error(`Received ${signal}`));
+  };
+  signalHandlers.set(signal, handler);
+  process.once(signal, handler);
+}
+
+try {
+  await deploymentPhase("standalone", "build", async () =>
+    docker(
+      "buildx",
+      "build",
+      "--load",
+      "--file",
+      "Dockerfile",
+      "--target",
+      "standalone",
+      "--build-arg",
+      `DEPLOYMENT_BUILD_ID=${uniqueId}`,
+      ...buildArguments,
+      "--tag",
+      standaloneImage,
+      ".",
+    ),
+  );
+  await deploymentPhase("runtime", "build", async () =>
+    docker(
+      "buildx",
+      "build",
+      "--load",
+      "--file",
+      "Dockerfile",
+      "--target",
+      "runtime",
+      "--build-arg",
+      `DEPLOYMENT_BUILD_ID=${uniqueId}`,
+      ...buildArguments,
+      "--tag",
+      runtimeImage,
+      ".",
+    ),
+  );
+  for (const volume of Object.values(volumes)) {
+    await docker("volume", "create", volume);
+  }
+  await docker("network", "create", network);
+
+  await runStartedDeployment(
+    "standalone",
+    "Standalone",
+    containers.standalone,
+    volumes.standalone,
+    standaloneImage,
+  );
+
+  await deploymentPhase("external-preparation", "prepare", async () =>
+    docker(
+      "run",
+      "--name",
+      containers.preparation,
+      "--network",
+      network,
+      "--volume",
+      `${volumes.prepared}:/data`,
+      standaloneImage,
+      "prepare-only",
+    ),
+  );
+  await deploymentPhase("external-preparation", "exit", async () => {
+    const state = await dockerWithTimeout(
+      10_000,
+      "inspect",
+      "--format={{.State.Status}}:{{.State.ExitCode}}",
+      containers.preparation,
+    );
+    if (state !== "exited:0") {
+      throw new Error(
+        `Preparation-only container must exit successfully, received ${state}.\n${await containerLogs(containers.preparation)}`,
+      );
+    }
+  });
+  await runStartedDeployment(
+    "runtime",
+    "Runtime",
+    containers.runtime,
+    volumes.prepared,
+    runtimeImage,
+  );
+
+  await deploymentPhase("fresh-runtime", "rejection", async () =>
+    assertUnpreparedRuntimeFails(),
+  );
+} catch (error) {
+  console.error(error);
+  console.error(await deploymentLogs());
+  process.exitCode = 1;
+} finally {
+  for (const signal of forwardedSignals) {
+    const handler = signalHandlers.get(signal);
+    if (handler) {
+      process.removeListener(signal, handler);
+    }
+  }
+  await cleanup();
+}

package/node_modules/@ykdz/preset-vike-app/native/template-dist/definition.d.ts

@@ -0,0 +1,35 @@
+import { type PresetProjectOptions } from "@ykdz/template-core/preset-definition";
+import type { GenerationContext } from "@ykdz/template-workspace/generation-context";
+import type { PackageContribution } from "@ykdz/template-workspace/package-contribution";
+import type { SharedRootContribution } from "@ykdz/template-workspace/shared-root-files";
+export declare const preset: {
+    readonly kind: "preset";
+    readonly metadata: {
+        readonly alias: string;
+        readonly title: string;
+        readonly description: string;
+    };
+    readonly operations: readonly import("@ykdz/template-core/preset-definition").PresetOperation[];
+    readonly nodes: Readonly<Record<string, import("@ykdz/template-core/preset-definition").PresetNode<import("@ykdz/template-workspace/reference-package").ReferencePackage<import("@ykdz/template-core/workspace-strategy").PackageCreationInput<unknown>, undefined>, never, never>>>;
+} & {
+    readonly owner?: import("@ykdz/template-core/preset-definition").PresetOwnerDeclaration;
+    readonly validateUpdate?: (options: PresetProjectOptions<GenerationContext, PackageContribution> & {
+        readonly targetRoot: string;
+    }) => void | Promise<void>;
+    readonly project?: (options: PresetProjectOptions<GenerationContext, PackageContribution>) => SharedRootContribution[];
+} & {
+    readonly nodes: {
+        web: {
+            reference: import("@ykdz/template-workspace/reference-package").ReferencePackage<import("@ykdz/template-core/workspace-strategy").PackageCreationInput<unknown>, undefined>;
+        };
+        database: {
+            reference: import("@ykdz/template-workspace/reference-package").ReferencePackage<import("@ykdz/template-core/workspace-strategy").PackageCreationInput<unknown>, undefined>;
+        };
+        migrations: {
+            reference: import("@ykdz/template-workspace/reference-package").ReferencePackage<import("@ykdz/template-core/workspace-strategy").PackageCreationInput<unknown>, undefined>;
+        };
+    };
+} & {
+    readonly prepareArtifact: () => import("@ykdz/template-workspace-authoring/content-artifact").PreparedNativeContentArtifact;
+};
+//# sourceMappingURL=definition.d.ts.map

package/node_modules/@ykdz/preset-vike-app/native/template-dist/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../template/definition.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,oBAAoB,EAE1B,MAAM,uCAAuC,CAAC;AAG/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6CAA6C,CAAC;AACrF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+CAA+C,CAAC;AACzF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AA4BzF,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;YALV,SAAS;;;YACJ,SAAS;;;YACP,SAAS;;;;;CAuDxB,CAAC"}

package/node_modules/@ykdz/preset-vike-app/native/template-dist/definition.js

@@ -0,0 +1,61 @@
+import { referencePackage as database } from "@ykdz/reference-vike-db/template";
+import { referencePackage as migrations } from "@ykdz/reference-vike-migrations/template";
+import { referencePackage as web } from "@ykdz/reference-vike-web/template";
+import { definePreset, presetOwnerFromManifest, } from "@ykdz/template-core/preset-definition";
+import { defineNativeContentArtifact } from "@ykdz/template-workspace-authoring/content-artifact";
+import presetPackage from "../package.json" with { type: "json" };
+import { projectVikeDeploymentContribution, vikeDeploymentResources, validateVikePackageTruth, } from "./deployment.js";
+const owner = presetOwnerFromManifest(presetPackage, "./template");
+function requireNode(nodeInstances, identity) {
+    const definition = nodeInstances.get(identity);
+    if (definition === undefined) {
+        throw new Error("Vike 应用预设缺少节点：" + identity);
+    }
+    return definition;
+}
+const nodes = {
+    web: { reference: web },
+    database: { reference: database },
+    migrations: { reference: migrations },
+};
+export const preset = defineNativeContentArtifact(definePreset({
+    metadata: {
+        alias: "vike-app",
+        title: "Vike 应用",
+        description: "组合 Vike Web、数据库和迁移包，并投影应用级准备与部署任务。",
+    },
+    operations: ["init"],
+    nodes,
+    owner,
+    validateUpdate({ targetRoot, contributions, nodeInstances, }) {
+        validateVikePackageTruth({
+            targetRoot,
+            contributions,
+            application: requireNode(nodeInstances, "web"),
+            database: requireNode(nodeInstances, "database"),
+            migrations: requireNode(nodeInstances, "migrations"),
+        });
+    },
+    project({ contributions, nodeInstances, }) {
+        const application = requireNode(nodeInstances, "web");
+        const databasePackage = requireNode(nodeInstances, "database");
+        const migrationPackage = requireNode(nodeInstances, "migrations");
+        const deployment = projectVikeDeploymentContribution({
+            contributions,
+            application,
+            database: databasePackage,
+            migrations: migrationPackage,
+        });
+        return [deployment];
+    },
+}), {
+    manifest: presetPackage,
+    resourceRoot: new URL("../", import.meta.url),
+    exportPath: "./template",
+    resources: vikeDeploymentResources,
+    executionDependencies: [
+        "@ykdz/template-workspace",
+        "@ykdz/template-workspace-authoring",
+        "yaml",
+    ],
+});

package/node_modules/@ykdz/preset-vike-app/native/template-dist/deployment.d.ts

@@ -0,0 +1,20 @@
+import type { PackageDefinition } from "@ykdz/template-core/project-blueprint";
+import type { NativeContentArtifactResource } from "@ykdz/template-workspace-authoring/content-artifact";
+import type { PackageContribution } from "@ykdz/template-workspace/package-contribution";
+import type { SharedRootContribution } from "@ykdz/template-workspace/shared-root-files";
+export declare const vikeDeploymentResources: readonly [NativeContentArtifactResource, NativeContentArtifactResource, NativeContentArtifactResource, NativeContentArtifactResource, NativeContentArtifactResource];
+/** 更新效果阶段保留数据库协作对当前包身份与任务命令的既有保证。 */
+export declare function validateVikePackageTruth(options: {
+    readonly targetRoot: string;
+    readonly contributions: readonly PackageContribution[];
+    readonly application: PackageDefinition;
+    readonly database: PackageDefinition;
+    readonly migrations: PackageDefinition;
+}): void;
+export declare function projectVikeDeploymentContribution(options: {
+    readonly contributions: readonly PackageContribution[];
+    readonly application: PackageDefinition;
+    readonly database: PackageDefinition;
+    readonly migrations: PackageDefinition;
+}): SharedRootContribution;
+//# sourceMappingURL=deployment.d.ts.map

package/node_modules/@ykdz/preset-vike-app/native/template-dist/deployment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployment.d.ts","sourceRoot":"","sources":["../template/deployment.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAE/E,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,qDAAqD,CAAC;AAOzG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+CAA+C,CAAC;AAEzF,OAAO,KAAK,EAEV,sBAAsB,EACvB,MAAM,4CAA4C,CAAC;AAwBpD,eAAO,MAAM,uBAAuB,sKAgByB,CAAC;AA6L9D,qCAAqC;AACrC,wBAAgB,wBAAwB,CAAC,OAAO,EAAE;IAChD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACvD,QAAQ,CAAC,WAAW,EAAE,iBAAiB,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAC;CACxC,GAAG,IAAI,CAwBP;AAiDD,wBAAgB,iCAAiC,CAAC,OAAO,EAAE;IACzD,QAAQ,CAAC,aAAa,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACvD,QAAQ,CAAC,WAAW,EAAE,iBAAiB,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAC;CACxC,GAAG,sBAAsB,CAkGzB"}