@fjall/components-infrastructure 11.0.0 → 12.0.0

package/dist/lib/patterns/aws/computeEcsTypes.d.ts

@@ -825,7 +825,7 @@ export interface EcsServiceConfig {
      * {
      *   services: [
      *     { name: "api", capacityProvider: "FARGATE" },
-     *     { name: "worker", capacityProvider: "EC2", ec2Config: { instanceType: "t4g.micro" } }
+     *     { name: "worker", capacityProvider: "EC2", ec2Config: { instanceType: "t4g.small" } }
      *   ]
      * }
      */

package/dist/lib/resources/aws/compute/ecsCapacityConfig.js

@@ -2,7 +2,7 @@ import { AmiHardwareType } from "aws-cdk-lib/aws-ecs";
 import { Token } from "aws-cdk-lib";
 import { CAPACITY_ANCHOR_MAX_LENGTH, CAPACITY_ANCHOR_PATTERN, CAPACITY_SLOT_MAX_LENGTH, CAPACITY_SLOT_PATTERN, DEFAULT_CAPACITY_SLOT } from "@fjall/util";
 import { toPascalCase } from "../../../utils/capitaliseString.js";
-import { DEFAULT_EC2_INSTANCE_TYPE, DEFAULT_EC2_MIN_CAPACITY, DEFAULT_EC2_MAX_CAPACITY, DEFAULT_EC2_INSTANCE_MONITORING, DEFAULT_ROLLING_UPDATE_PAUSE_SECONDS, DEFAULT_WARM_POOL_MIN_SIZE, DEFAULT_WARM_POOL_REUSE_ON_SCALE_IN, INSTANCE_REFRESH_DEFAULT_MAX_HEALTHY, INSTANCE_REFRESH_DEFAULT_MIN_HEALTHY, INSTANCE_REFRESH_PDV_MAX_HEALTHY, INSTANCE_REFRESH_PDV_MIN_HEALTHY, inferAmiHardwareType } from "./ecsConstants.js";
+import { DEFAULT_ECS_EC2_INSTANCE_TYPE, DEFAULT_EC2_MIN_CAPACITY, DEFAULT_EC2_MAX_CAPACITY, DEFAULT_EC2_INSTANCE_MONITORING, DEFAULT_ROLLING_UPDATE_PAUSE_SECONDS, DEFAULT_WARM_POOL_MIN_SIZE, DEFAULT_WARM_POOL_REUSE_ON_SCALE_IN, INSTANCE_REFRESH_DEFAULT_MAX_HEALTHY, INSTANCE_REFRESH_DEFAULT_MIN_HEALTHY, INSTANCE_REFRESH_PDV_MAX_HEALTHY, INSTANCE_REFRESH_PDV_MIN_HEALTHY, inferAmiHardwareType } from "./ecsConstants.js";
 /**
  * Every `Ec2CapacityConfig` field, classified. The `Record<keyof …, …>`
  * satisfies-shape is a compile-time exhaustiveness guard in compiled `src/`
@@ -40,8 +40,7 @@ const OPAQUE_ASG_FIELDS = fieldsWithRole("property:opaque");
 /** The `"ARM" | "STANDARD"` label the config key and drift compare share. */
 function resolvedAmiHardwareLabel(config) {
     return (config.amiHardwareType ??
-        (inferAmiHardwareType(config.instanceType ?? DEFAULT_EC2_INSTANCE_TYPE) ===
-            AmiHardwareType.ARM
+        (inferAmiHardwareType(config.instanceType ?? DEFAULT_ECS_EC2_INSTANCE_TYPE) === AmiHardwareType.ARM
             ? "ARM"
             : "STANDARD"));
 }
@@ -54,7 +53,7 @@ function resolvedAmiHardwareLabel(config) {
  * default (`desiredCapacity`, `associatePublicIpAddress`) compare raw.
  */
 const SCALAR_ASG_FIELD_RESOLVERS = {
-    instanceType: (c) => c.instanceType ?? DEFAULT_EC2_INSTANCE_TYPE,
+    instanceType: (c) => c.instanceType ?? DEFAULT_ECS_EC2_INSTANCE_TYPE,
     amiHardwareType: resolvedAmiHardwareLabel,
     minCapacity: (c) => c.minCapacity ?? DEFAULT_EC2_MIN_CAPACITY,
     maxCapacity: (c) => c.maxCapacity ?? DEFAULT_EC2_MAX_CAPACITY,
@@ -246,6 +245,11 @@ export const LEGACY_KEY_FIELDS = [
     "persistentDataVolume",
     "availabilityZones"
 ];
+// The ECS EC2 instance-type default as it stood when the pre-6.0 legacy key
+// format was live. FROZEN: the legacy checksum must keep matching what
+// deployed pre-6.0 stacks derived, so it must not follow
+// DEFAULT_ECS_EC2_INSTANCE_TYPE.
+const LEGACY_KEY_DEFAULT_INSTANCE_TYPE = "t4g.micro";
 /**
  * The pre-6.0 config-derived identity key. SURVIVES ONLY as the legacy
  * checksum behind manifest identity-alias hints (`legacyKey`/`legacyAnchor`)
@@ -253,7 +257,7 @@ export const LEGACY_KEY_FIELDS = [
  * ASG sharing keys on the capacity SLOT.
  */
 export function getEc2ConfigKey(ec2Config) {
-    const instanceType = ec2Config.instanceType ?? DEFAULT_EC2_INSTANCE_TYPE;
+    const instanceType = ec2Config.instanceType ?? LEGACY_KEY_DEFAULT_INSTANCE_TYPE;
     const amiHardwareType = resolvedAmiHardwareLabel(ec2Config);
     const warmPoolKey = ec2Config.warmPool
         ? `wp${ec2Config.warmPool.minSize ?? DEFAULT_WARM_POOL_MIN_SIZE}-${ec2Config.warmPool.reuseOnScaleIn ?? DEFAULT_WARM_POOL_REUSE_ON_SCALE_IN}`

package/dist/lib/resources/aws/compute/ecsConstants.d.ts

@@ -2,6 +2,7 @@ import { Monitoring } from "aws-cdk-lib/aws-autoscaling";
 import { AmiHardwareType } from "aws-cdk-lib/aws-ecs";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
 export declare const DEFAULT_EC2_INSTANCE_TYPE = "t4g.micro";
+export declare const DEFAULT_ECS_EC2_INSTANCE_TYPE = "t4g.small";
 export declare const DEFAULT_WARM_POOL_MIN_SIZE = 1;
 export declare const DEFAULT_WARM_POOL_REUSE_ON_SCALE_IN = false;
 export declare const DEFAULT_LOG_RETENTION_DAYS = 14;

package/dist/lib/resources/aws/compute/ecsConstants.js

@@ -1,8 +1,16 @@
 import { Monitoring } from "aws-cdk-lib/aws-autoscaling";
 import { AmiHardwareType } from "aws-cdk-lib/aws-ecs";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
-// Canonical source: @fjall/generator schemas/constants.ts — keep in sync
+// Canonical source: @fjall/generator schemas/constants.ts — keep in sync.
+// Standalone EC2 instances (the compute:ec2 pattern) only; ECS EC2 capacity
+// defaults to DEFAULT_ECS_EC2_INSTANCE_TYPE below.
 export const DEFAULT_EC2_INSTANCE_TYPE = "t4g.micro";
+// Smallest type whose usable memory (nominal 2048 minus the agent/OS reserve)
+// fits the default container hard limit (1024) plus the schema-gate sidecar
+// (512). A t4g.micro registers under 1024 with ECS, so a micro default made
+// every defaults-only EC2 service structurally unplaceable — the same class
+// as the 2026-08-12 deploy-worker wedge, present from first deploy.
+export const DEFAULT_ECS_EC2_INSTANCE_TYPE = "t4g.small";
 export const DEFAULT_WARM_POOL_MIN_SIZE = 1;
 // reuseOnScaleIn: true returns scaled-in instances to the warm pool Stopped,
 // which can strand ECS tasks DRAINING indefinitely (the 2026-06-04 outage).

package/dist/lib/resources/aws/compute/ecsServiceFactory.js

@@ -11,7 +11,7 @@ import { Ec2Instance } from "./ec2.js";
 import { vpcHasNatGateways } from "../../../utils/vpcUtils.js";
 import { toPascalCase } from "../../../utils/capitaliseString.js";
 import { stackScopedExportName } from "../../../utils/exportNaming.js";
-import { DEFAULT_EC2_INSTANCE_TYPE, DEFAULT_EC2_MIN_CAPACITY, DEFAULT_EC2_MAX_CAPACITY, DEFAULT_EC2_INSTANCE_MONITORING, DEFAULT_WARM_POOL_MIN_SIZE, DEFAULT_WARM_POOL_REUSE_ON_SCALE_IN, DEFAULT_HEALTH_CHECK_GRACE_SECONDS, DEFAULT_MIN_HEALTHY_PERCENT, DEFAULT_MAX_HEALTHY_PERCENT, DEFAULT_DESIRED_COUNT, inferAmiHardwareType } from "./ecsConstants.js";
+import { DEFAULT_ECS_EC2_INSTANCE_TYPE, DEFAULT_EC2_MIN_CAPACITY, DEFAULT_EC2_MAX_CAPACITY, DEFAULT_EC2_INSTANCE_MONITORING, DEFAULT_WARM_POOL_MIN_SIZE, DEFAULT_WARM_POOL_REUSE_ON_SCALE_IN, DEFAULT_HEALTH_CHECK_GRACE_SECONDS, DEFAULT_MIN_HEALTHY_PERCENT, DEFAULT_MAX_HEALTHY_PERCENT, DEFAULT_DESIRED_COUNT, inferAmiHardwareType } from "./ecsConstants.js";
 import { assertAnchorUnique, assertSharedAsgConfigMatches, assertValidCapacitySlot, getEc2ConfigKey, legacyAnchorFromKey, LEGACY_KEY_FIELDS, resolveCapacityAnchor, resolveCapacitySlot } from "./ecsCapacityConfig.js";
 import { lookupCapacityIdentityPin } from "../../../utils/capacityIdentityContext.js";
 import { getCurrentCollector } from "../../../utils/manifestWriter.js";
@@ -114,7 +114,7 @@ export function getOrCreateAsgCapacityProvider(ctx, serviceProps, state) {
             legacyKeyFields: [...LEGACY_KEY_FIELDS]
         });
     }
-    const instanceType = ec2Config.instanceType ?? DEFAULT_EC2_INSTANCE_TYPE;
+    const instanceType = ec2Config.instanceType ?? DEFAULT_ECS_EC2_INSTANCE_TYPE;
     const amiHardwareType = ec2Config.amiHardwareType
         ? ec2Config.amiHardwareType === "STANDARD"
             ? AmiHardwareType.STANDARD

package/dist/lib/resources/aws/compute/ecsTypes.d.ts

@@ -114,7 +114,7 @@ export interface Ec2CapacityConfig {
      * should rely on the slot derivation.
      */
     identityAnchor?: string;
-    /** EC2 instance type. Default: "t4g.micro" */
+    /** EC2 instance type. Default: "t4g.small" */
     instanceType?: string;
     /** AMI hardware type. Default: "ARM" (Graviton - better cost/performance) */
     amiHardwareType?: "ARM" | "STANDARD";

package/dist/lib/resources/aws/compute/ecsValidation.d.ts

@@ -121,16 +121,15 @@ interface Ec2MemoryFitInput {
  * of a t4g.medium's 3835 registered), which this guard converts into a synth
  * error.
  *
- * Three verdicts:
- *
- * - demand >= nominal AND the sizing is explicit (`ec2Config.instanceType` or
- *   `ec2Config.memoryLimitMiB` set) → THROW. Zero false positives by
- *   construction: registered < nominal always, so nothing that deploys today
- *   can trip it.
- * - demand >= nominal on an all-defaults `ec2Config` → WARNING only. The
- *   default instanceType/memory combo (t4g.micro + 1024) is itself
- *   oversubscribed, so throwing would reject every bare `ec2Config: {}`
- *   consumer; fixing the defaults is a separate decision.
+ * Two verdicts:
+ *
+ * - demand >= nominal → THROW. Zero false positives by construction:
+ *   registered < nominal always, so nothing that deploys today can trip it.
+ *   Applies equally to the defaulted instance type
+ *   ({@link DEFAULT_ECS_EC2_INSTANCE_TYPE}) — the defaults combo (t4g.small +
+ *   1024, or + the gate's 512) fits with headroom, so an oversubscribed bare
+ *   `ec2Config: {}` means the caller added containers without sizing and the
+ *   task is just as unplaceable as an explicitly-sized one.
  * - demand > nominal − {@link estimatedEc2MemoryReserveMiB} → WARNING. The
  *   demand fits nominal but sits inside the estimated agent/OS reserve band,
  *   where placement depends on the AMI's exact registered memory.

package/dist/lib/resources/aws/compute/ecsValidation.js

@@ -4,7 +4,7 @@ import { evaluateBakeGuard } from "@fjall/util/docker";
 import { SCHEMA_GATE_CONTAINER_NAME } from "@fjall/util/migration";
 import { toKebab, SSM_COMPONENT_PATTERN, SSM_COMPONENT_ERROR, SECRET_NAME_PATTERN, SECRET_NAME_ERROR } from "@fjall/util";
 import { ScalingType } from "./ecsTypes.js";
-import { DEFAULT_EC2_CONTAINER_MEMORY_MIB, DEFAULT_EC2_INSTANCE_TYPE, SCHEMA_GATE_CONTAINER_MEMORY_MIB, estimatedEc2MemoryReserveMiB, nominalEc2InstanceMemoryMiB, resolveEc2ContainerMemoryMiB } from "./ecsConstants.js";
+import { DEFAULT_EC2_CONTAINER_MEMORY_MIB, DEFAULT_ECS_EC2_INSTANCE_TYPE, SCHEMA_GATE_CONTAINER_MEMORY_MIB, estimatedEc2MemoryReserveMiB, nominalEc2InstanceMemoryMiB, resolveEc2ContainerMemoryMiB } from "./ecsConstants.js";
 import { validateSharedEc2CapacityConfig } from "./ecsCapacityConfig.js";
 /**
  * Validates ECS cluster props before construction.
@@ -308,16 +308,15 @@ export function validateEc2ServiceSizing(service) {
  * of a t4g.medium's 3835 registered), which this guard converts into a synth
  * error.
  *
- * Three verdicts:
+ * Two verdicts:
  *
- * - demand >= nominal AND the sizing is explicit (`ec2Config.instanceType` or
- *   `ec2Config.memoryLimitMiB` set) → THROW. Zero false positives by
- *   construction: registered < nominal always, so nothing that deploys today
- *   can trip it.
- * - demand >= nominal on an all-defaults `ec2Config` → WARNING only. The
- *   default instanceType/memory combo (t4g.micro + 1024) is itself
- *   oversubscribed, so throwing would reject every bare `ec2Config: {}`
- *   consumer; fixing the defaults is a separate decision.
+ * - demand >= nominal → THROW. Zero false positives by construction:
+ *   registered < nominal always, so nothing that deploys today can trip it.
+ *   Applies equally to the defaulted instance type
+ *   ({@link DEFAULT_ECS_EC2_INSTANCE_TYPE}) — the defaults combo (t4g.small +
+ *   1024, or + the gate's 512) fits with headroom, so an oversubscribed bare
+ *   `ec2Config: {}` means the caller added containers without sizing and the
+ *   task is just as unplaceable as an explicitly-sized one.
  * - demand > nominal − {@link estimatedEc2MemoryReserveMiB} → WARNING. The
  *   demand fits nominal but sits inside the estimated agent/OS reserve band,
  *   where placement depends on the AMI's exact registered memory.
@@ -340,7 +339,8 @@ export function validateEc2ServiceSizing(service) {
 export function validateEc2TaskMemoryFit(service) {
     if (service.capacityProvider !== "EC2")
         return [];
-    const instanceType = service.ec2Config?.instanceType ?? DEFAULT_EC2_INSTANCE_TYPE;
+    const instanceTypeIsDefaulted = service.ec2Config?.instanceType === undefined;
+    const instanceType = service.ec2Config?.instanceType ?? DEFAULT_ECS_EC2_INSTANCE_TYPE;
     const nominal = nominalEc2InstanceMemoryMiB(instanceType);
     if (nominal === undefined)
         return [];
@@ -358,31 +358,23 @@ export function validateEc2TaskMemoryFit(service) {
         accounting.push(`${container.name ?? "(default)"}=${memory}`);
     }
     const reserve = estimatedEc2MemoryReserveMiB(nominal);
-    const explicitlySized = service.ec2Config?.instanceType !== undefined ||
-        service.ec2Config?.memoryLimitMiB !== undefined;
+    const instanceTypeLabel = instanceTypeIsDefaulted
+        ? `${instanceType} (the ECS EC2 default)`
+        : instanceType;
     if (demand >= nominal) {
-        if (explicitlySized) {
-            throw new Error(`Service '${service.name}': container hard memory limits total ${demand} MiB ` +
-                `(${accounting.join(" + ")}), which cannot fit a ${instanceType} — ECS ` +
-                `registers less than the nominal ${nominal} MiB per instance (the ECS agent ` +
-                `and OS reserve roughly ${reserve} MiB), so no task of this shape can ever ` +
-                `be placed, on any instance count. The stack deploys cleanly while ` +
-                `desiredCount is 0, then wedges at the first scale-up. Lower ` +
-                `ec2Config.memoryLimitMiB (every app container takes that hard limit), ` +
-                `choose a larger ec2Config.instanceType, or run fewer containers in the task.`);
-        }
-        return [
-            `Service '${service.name}': container hard memory limits total ${demand} MiB ` +
-                `(${accounting.join(" + ")}), which cannot fit the default ${instanceType} ` +
-                `(nominal ${nominal} MiB, less after the ECS agent/OS reserve) — no task of ` +
-                `this shape can be placed at runtime. Set ec2Config.instanceType to a ` +
-                `larger type or lower ec2Config.memoryLimitMiB.`
-        ];
+        throw new Error(`Service '${service.name}': container hard memory limits total ${demand} MiB ` +
+            `(${accounting.join(" + ")}), which cannot fit a ${instanceTypeLabel} — ECS ` +
+            `registers less than the nominal ${nominal} MiB per instance (the ECS agent ` +
+            `and OS reserve roughly ${reserve} MiB), so no task of this shape can ever ` +
+            `be placed, on any instance count. The stack deploys cleanly while ` +
+            `desiredCount is 0, then wedges at the first scale-up. Lower ` +
+            `ec2Config.memoryLimitMiB (every app container takes that hard limit), ` +
+            `choose a larger ec2Config.instanceType, or run fewer containers in the task.`);
     }
     if (demand > nominal - reserve) {
         return [
             `Service '${service.name}': container hard memory limits total ${demand} MiB ` +
-                `of a ${instanceType}'s nominal ${nominal} MiB — inside the ECS agent/OS ` +
+                `of a ${instanceTypeLabel}'s nominal ${nominal} MiB — inside the ECS agent/OS ` +
                 `reserve band (estimated usable ~${nominal - reserve} MiB). Placement can ` +
                 `fail depending on the AMI's exact registered memory. Leave ~${reserve} MiB ` +
                 `headroom: lower ec2Config.memoryLimitMiB or choose a larger ` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fjall/components-infrastructure",
-  "version": "11.0.0",
+  "version": "12.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fjall-tech/fjall.git",
@@ -80,8 +80,8 @@
   },
   "dependencies": {
     "@aws-sdk/client-organizations": "^3.1098.0",
-    "@fjall/generator": "^11.0.0",
-    "@fjall/util": "^11.0.0",
+    "@fjall/generator": "^12.0.0",
+    "@fjall/util": "^12.0.0",
     "constructs": "^10.7.2"
   },
   "overrides": {