@ykdz/template 0.0.31 → 0.0.33

package/node_modules/@ykdz/template-builtin-presets/templates/vike-app/web/scripts/check-standalone-deployment.ts

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
 import path from "node:path";
 
 const webRoot = path.resolve(import.meta.dirname, "..");
@@ -194,7 +195,34 @@ async function deploymentLogs(): Promise<string> {
   return logs.join("\n");
 }
 
-async function publishedBaseUrl(container: string): Promise<string> {
+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",
@@ -207,26 +235,33 @@ async function publishedBaseUrl(container: string): Promise<string> {
       `Could not determine the published web port: ${portOutput}`,
     );
   }
-  return `http://127.0.0.1:${match[1]}`;
+  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,
-  baseUrl: string,
-): Promise<void> {
+  baseUrls: readonly string[],
+): Promise<string> {
   const timeout = readinessTimeoutMs();
   const deadline = Date.now() + timeout;
   while (Date.now() < deadline) {
-    try {
-      const response = await fetch(baseUrl, {
-        signal: AbortSignal.timeout(2_000),
-      });
-      if (response.ok) {
-        return;
+    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.
       }
-    } catch {
-      // The container may still be starting the server.
     }
 
     const running = await dockerWithTimeout(
@@ -244,7 +279,7 @@ async function waitForReady(
   }
 
   throw new Error(
-    `${phase} container was not ready within ${timeout}ms.\n${await containerLogs(container)}`,
+    `${phase} container was not ready at ${baseUrls.join(", ")} within ${timeout}ms.\n${await containerLogs(container)}`,
   );
 }
 
@@ -313,17 +348,17 @@ async function runStartedDeployment(
       "--network",
       network,
       "--publish",
-      "127.0.0.1::3000",
+      "0.0.0.0::3000",
       "--volume",
       `${volume}:/data`,
       image,
     ),
   );
-  const baseUrl = await deploymentPhase(mode, "start", async () =>
-    publishedBaseUrl(container),
+  const baseUrls = await deploymentPhase(mode, "start", async () =>
+    publishedBaseUrls(container),
   );
-  await deploymentPhase(mode, "readiness", async () =>
-    waitForReady(readinessLabel, container, baseUrl),
+  const baseUrl = await deploymentPhase(mode, "readiness", async () =>
+    waitForReady(readinessLabel, container, baseUrls),
   );
   await deploymentPhase(mode, "identity", async () =>
     assertProcessIdentity(readinessLabel, container),
@@ -344,12 +379,12 @@ async function assertUnpreparedRuntimeFails(): Promise<void> {
     "--network",
     network,
     "--publish",
-    "127.0.0.1::3000",
+    "0.0.0.0::3000",
     "--volume",
     `${volumes.unprepared}:/data`,
     runtimeImage,
   );
-  const baseUrl = await publishedBaseUrl(containers.unprepared);
+  const baseUrls = await publishedBaseUrls(containers.unprepared);
   const deadline = Date.now() + 30_000;
 
   while (Date.now() < deadline) {
@@ -362,16 +397,21 @@ async function assertUnpreparedRuntimeFails(): Promise<void> {
       (state) => ({ state }),
       (error: unknown) => ({ error }),
     );
-    const probe = await fetch(baseUrl, {
-      signal: AbortSignal.timeout(500),
-    }).then(
-      (response) => ({ response }),
-      () => ({ response: undefined }),
+    const probes = await Promise.all(
+      baseUrls.map((baseUrl) =>
+        fetch(baseUrl, {
+          signal: AbortSignal.timeout(500),
+        }).then(
+          (response) => ({ baseUrl, response }),
+          () => ({ baseUrl, response: undefined }),
+        ),
+      ),
     );
 
-    if (probe.response !== undefined) {
+    const servedProbe = probes.find((probe) => probe.response !== undefined);
+    if (servedProbe?.response !== undefined) {
       throw new Error(
-        `Unprepared runtime served HTTP ${probe.response.status} before exiting.`,
+        `Unprepared runtime served HTTP ${servedProbe.response.status} at ${servedProbe.baseUrl} before exiting.`,
       );
     }
 

package/node_modules/@ykdz/template-builtin-presets/templates/vike-app/web/tsconfig.app.json

@@ -1,25 +1,19 @@
 {
-  "extends": "@vue/tsconfig/tsconfig.dom.json",
+  "extends": [
+    "@vue/tsconfig/tsconfig.dom.json",
+    "{{TYPESCRIPT_CONFIG_PACKAGE}}/base.json"
+  ],
   "compilerOptions": {
     "composite": true,
     "customConditions": ["source"],
-    "exactOptionalPropertyTypes": true,
-    "forceConsistentCasingInFileNames": true,
-    "isolatedModules": true,
+    "exactOptionalPropertyTypes": false,
     "module": "esnext",
     "moduleResolution": "bundler",
-    "noEmitOnError": true,
-    "noFallthroughCasesInSwitch": true,
-    "noImplicitOverride": true,
-    "noImplicitReturns": true,
-    "noUncheckedIndexedAccess": true,
     "rewriteRelativeImportExtensions": false,
     "skipLibCheck": true,
-    "strict": true,
     "target": "es2023",
     "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
-    "types": ["node"],
-    "verbatimModuleSyntax": true
+    "types": ["node"]
   },
   "include": [
     "+server.ts",

package/node_modules/@ykdz/template-builtin-presets/templates/vike-app/web/tsconfig.node.json

@@ -1,26 +1,17 @@
 {
+  "extends": "{{TYPESCRIPT_CONFIG_PACKAGE}}/base.json",
   "compilerOptions": {
     "composite": true,
     "customConditions": ["source"],
     "erasableSyntaxOnly": true,
-    "exactOptionalPropertyTypes": true,
-    "forceConsistentCasingInFileNames": true,
-    "isolatedModules": true,
     "lib": ["ESNext", "DOM", "DOM.Iterable"],
     "module": "esnext",
     "moduleResolution": "bundler",
-    "noEmitOnError": true,
-    "noFallthroughCasesInSwitch": true,
-    "noImplicitOverride": true,
-    "noImplicitReturns": true,
-    "noUncheckedIndexedAccess": true,
     "rewriteRelativeImportExtensions": false,
     "skipLibCheck": true,
-    "strict": true,
     "target": "es2023",
     "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
-    "types": ["node"],
-    "verbatimModuleSyntax": true
+    "types": ["node"]
   },
   "include": [
     "playwright.config.ts",

package/node_modules/@ykdz/template-builtin-presets/templates/vike-app/web/tsconfig.test.json

@@ -3,7 +3,6 @@
   "compilerOptions": {
     "customConditions": ["source"],
     "lib": ["ESNext", "DOM", "DOM.Iterable"],
-    "skipLibCheck": true,
     "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.test.tsbuildinfo",
     "types": ["node", "vitest/globals"]
   },

package/node_modules/@ykdz/template-builtin-presets/templates/vue-app/playwright.config.ts

@@ -17,8 +17,9 @@ export default defineConfig({
   testDir: "./test/e2e",
   use: {
     baseURL: previewUrl,
-    trace: "on-first-retry",
+    trace: "retain-on-failure",
   },
+  reporter: [["list"], ["html"]],
   webServer: {
     command: `pnpm run preview --host 127.0.0.1 --port ${previewPort}`,
     reuseExistingServer: !process.env.CI,

package/node_modules/@ykdz/template-builtin-presets/templates/vue-hono-app/api/tsconfig.json

@@ -1,26 +1,16 @@
 {
+  "extends": "{{TYPESCRIPT_CONFIG_PACKAGE}}/base.json",
   "compilerOptions": {
     "composite": true,
     "customConditions": ["source"],
     "declaration": true,
     "declarationMap": true,
     "erasableSyntaxOnly": true,
-    "exactOptionalPropertyTypes": true,
-    "forceConsistentCasingInFileNames": true,
-    "isolatedModules": true,
     "module": "nodenext",
     "moduleResolution": "nodenext",
-    "noEmitOnError": true,
-    "noFallthroughCasesInSwitch": true,
-    "noImplicitOverride": true,
-    "noImplicitReturns": true,
-    "noUncheckedIndexedAccess": true,
     "rewriteRelativeImportExtensions": true,
-    "skipLibCheck": false,
-    "strict": true,
     "target": "es2023",
-    "types": ["node", "vitest/globals"],
-    "verbatimModuleSyntax": true
+    "types": ["node", "vitest/globals"]
   },
   "include": ["src/**/*.ts", "test/**/*.ts", "vitest.config.ts"]
 }

package/node_modules/@ykdz/template-builtin-presets/templates/vue-hono-app/web/playwright.config.ts

@@ -20,8 +20,10 @@ export default defineConfig({
   testDir: "./test/e2e",
   use: {
     baseURL: webBaseUrl,
+    trace: "retain-on-failure",
     ...devices["Desktop Chrome"],
   },
+  reporter: [["list"], ["html"]],
   webServer: [
     {
       command: `PORT=${apiPort} pnpm --dir ../api run start`,

package/node_modules/@ykdz/template-core/dist/ci-diagnostic-artifact.d.ts

@@ -0,0 +1,19 @@
+import type { PackageBoundaryOwner } from "./module-graph.ts";
+/** Closed, owner-scoped native evidence a Package Contribution may retain in CI. */
+export type CiDiagnosticArtifactDeclaration = {
+    readonly kind: "playwright";
+    readonly owner: PackageBoundaryOwner;
+};
+/**
+ * Validates the intentionally closed diagnostic declaration surface.  It does
+ * not accept paths: native paths are derived only after the owner is known.
+ */
+export declare function assertCiDiagnosticArtifactDeclaration(value: unknown): CiDiagnosticArtifactDeclaration;
+/**
+ * Composes closed native diagnostics independently of presets and environment
+ * preparation. Equivalent declarations collapse into stable owner order.
+ */
+export declare function composeCiDiagnosticArtifacts(options: {
+    readonly packagePaths: readonly string[];
+    readonly declarations: readonly unknown[];
+}): readonly CiDiagnosticArtifactDeclaration[];

package/node_modules/@ykdz/template-core/dist/ci-diagnostic-artifact.js

@@ -0,0 +1,68 @@
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value).toSorted();
+    const expected = [...keys].toSorted();
+    return (actual.length === expected.length &&
+        actual.every((key, index) => key === expected[index]));
+}
+const reservedWorkspaceCollections = new Set([
+    ".git",
+    ".github",
+    ".devcontainer",
+    ".template",
+    "node_modules",
+    "dist",
+    "target",
+]);
+function isSafePackagePath(value) {
+    return (/^[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9-]*$/u.test(value) &&
+        !reservedWorkspaceCollections.has(value.split("/", 1)[0]));
+}
+/**
+ * Validates the intentionally closed diagnostic declaration surface.  It does
+ * not accept paths: native paths are derived only after the owner is known.
+ */
+export function assertCiDiagnosticArtifactDeclaration(value) {
+    if (!isRecord(value) || !hasExactKeys(value, ["kind", "owner"])) {
+        throw new Error("CI Diagnostic Artifact declarations may contain only kind and owner");
+    }
+    if (value.kind !== "playwright") {
+        throw new Error("Unsupported CI Diagnostic Artifact kind");
+    }
+    if (!isRecord(value.owner) || !hasExactKeys(value.owner, ["kind", "path"])) {
+        throw new Error("CI Diagnostic Artifact requires a Package Boundary owner");
+    }
+    if (value.owner.kind !== "package-boundary" ||
+        typeof value.owner.path !== "string" ||
+        !isSafePackagePath(value.owner.path)) {
+        throw new Error("CI Diagnostic Artifact owner has an unsafe Package Boundary path");
+    }
+    return {
+        kind: "playwright",
+        owner: { kind: "package-boundary", path: value.owner.path },
+    };
+}
+/**
+ * Composes closed native diagnostics independently of presets and environment
+ * preparation. Equivalent declarations collapse into stable owner order.
+ */
+export function composeCiDiagnosticArtifacts(options) {
+    for (const packagePath of options.packagePaths) {
+        if (!isSafePackagePath(packagePath)) {
+            throw new Error(`CI Diagnostic Artifact Package Boundary path is unsafe: ${packagePath}`);
+        }
+    }
+    const owners = new Set(options.packagePaths);
+    const artifacts = new Map();
+    for (const value of options.declarations) {
+        const declaration = assertCiDiagnosticArtifactDeclaration(value);
+        if (!owners.has(declaration.owner.path)) {
+            throw new Error(`CI Diagnostic Artifact owner is not a declared Package Boundary: ${declaration.owner.path}`);
+        }
+        const key = `${declaration.kind}:${declaration.owner.path}`;
+        artifacts.set(key, declaration);
+    }
+    return [...artifacts.values()].toSorted((left, right) => left.owner.path.localeCompare(right.owner.path));
+}

package/node_modules/@ykdz/template-core/dist/development-container-tool-layer.d.ts

@@ -0,0 +1,56 @@
+import { type TemplateSourceHandle } from "./renderer.ts";
+export type DevelopmentContainerToolLayerBuildArgument = {
+    readonly name: string;
+    readonly value: string;
+};
+export type DevelopmentContainerToolLayerMount = {
+    readonly identity: string;
+    readonly type: "bind" | "volume";
+    readonly source: string;
+    readonly target: string;
+};
+export type DevelopmentContainerToolLayerProbe = {
+    readonly identity: string;
+    readonly command: string;
+    readonly args?: readonly string[] | undefined;
+    readonly failureMessage?: string | undefined;
+};
+export type DevelopmentContainerToolLayer = {
+    readonly identity: string;
+    readonly dockerfile: {
+        readonly source: TemplateSourceHandle;
+        readonly from: string;
+    };
+    readonly requires?: readonly string[] | undefined;
+    readonly buildArguments?: readonly DevelopmentContainerToolLayerBuildArgument[] | undefined;
+    readonly mounts?: readonly DevelopmentContainerToolLayerMount[] | undefined;
+    readonly probes?: readonly DevelopmentContainerToolLayerProbe[] | undefined;
+};
+export type PlannedDevelopmentContainerToolLayer = DevelopmentContainerToolLayer & {
+    readonly kind: "base" | "optional";
+};
+export type DevelopmentContainerToolLayerPlan = {
+    readonly layers: readonly PlannedDevelopmentContainerToolLayer[];
+    readonly buildArguments: readonly DevelopmentContainerToolLayerBuildArgument[];
+    readonly mounts: readonly DevelopmentContainerToolLayerMount[];
+    readonly probes: readonly DevelopmentContainerToolLayerProbe[];
+};
+type DevelopmentContainerDockerfileFragment = {
+    readonly identity: string;
+    readonly kind: "base" | "optional";
+    readonly from: string;
+    readonly text: string;
+};
+export declare function validateDevelopmentContainerDockerfileFragments(options: {
+    readonly baseFragment: Omit<DevelopmentContainerDockerfileFragment, "kind">;
+    readonly fragments?: readonly Omit<DevelopmentContainerDockerfileFragment, "kind">[];
+}): void;
+export declare function planDevelopmentContainerToolLayersSync(options: {
+    readonly baseLayer: DevelopmentContainerToolLayer;
+    readonly layers?: readonly DevelopmentContainerToolLayer[] | undefined;
+}): DevelopmentContainerToolLayerPlan;
+export declare function planDevelopmentContainerToolLayers(options: {
+    readonly baseLayer: DevelopmentContainerToolLayer;
+    readonly layers?: readonly DevelopmentContainerToolLayer[] | undefined;
+}): Promise<DevelopmentContainerToolLayerPlan>;
+export {};