@awsless/awsless 0.0.323 → 0.0.326

package/dist/bin.js

@@ -322,7 +322,7 @@ var bootstrapAwsless = async (props) => {
     hasStateBucket(s3, props.accountId)
   ]);
   if (!table2 || !bucket) {
-    log.warn(`Your Awsless hasn't been bootstrapped yet.`);
+    log.warn(`Awsless hasn't been bootstrapped yet.`);
     if (!process.env.SKIP_PROMPT) {
       const confirmed = await confirm({
         message: "Would you like to bootstrap now?"
@@ -338,7 +338,7 @@ var bootstrapAwsless = async (props) => {
       if (!bucket) {
         await createStateBucket(s3, props.accountId);
       }
-      update("Done deploying the bootstrap stack");
+      update("Done deploying the bootstrap stack.");
     });
   } else {
     log.step("Awsless has already been bootstrapped.");
@@ -370,7 +370,7 @@ var debug = (...parts) => {
 };
 
 // src/config/app.ts
-import { z as z18 } from "zod";
+import { z as z20 } from "zod";
 
 // src/feature/auth/schema.ts
 import { z as z7 } from "zod";
@@ -915,8 +915,111 @@ var RestDefaultSchema = z16.record(
 ).optional().describe("Define your global REST API's.");
 var RestSchema = z16.record(ResourceIdSchema, z16.record(RouteSchema2, FunctionSchema)).optional().describe("Define routes in your stack for your global REST API.");
 
-// src/config/schema/region.ts
+// src/feature/store/schema.ts
 import { z as z17 } from "zod";
+var DeletionProtectionSchema = z17.boolean().describe("Specifies if you want to protect the store from being deleted by awsless.");
+var StoreDefaultSchema = z17.object({
+  deletionProtection: DeletionProtectionSchema.optional()
+}).optional();
+var StoresSchema = z17.union([
+  z17.array(ResourceIdSchema).transform((list4) => {
+    const stores = {};
+    for (const key of list4) {
+      stores[key] = {};
+    }
+    return stores;
+  }),
+  z17.record(
+    ResourceIdSchema,
+    z17.object({
+      // cors: CorsSchema,
+      deletionProtection: DeletionProtectionSchema.optional(),
+      versioning: z17.boolean().default(false).describe("Enable versioning of your store."),
+      events: z17.object({
+        // create
+        "created:*": FunctionSchema.optional().describe(
+          "Subscribe to notifications regardless of the API that was used to create an object."
+        ),
+        "created:put": FunctionSchema.optional().describe(
+          "Subscribe to notifications when an object is created using the PUT API operation."
+        ),
+        "created:post": FunctionSchema.optional().describe(
+          "Subscribe to notifications when an object is created using the POST API operation."
+        ),
+        "created:copy": FunctionSchema.optional().describe(
+          "Subscribe to notifications when an object is created using the COPY API operation."
+        ),
+        "created:upload": FunctionSchema.optional().describe(
+          "Subscribe to notifications when an object multipart upload has been completed."
+        ),
+        // remove
+        "removed:*": FunctionSchema.optional().describe(
+          "Subscribe to notifications when an object is deleted or a delete marker for a versioned object is created."
+        ),
+        "removed:delete": FunctionSchema.optional().describe(
+          "Subscribe to notifications when an object is deleted"
+        ),
+        "removed:marker": FunctionSchema.optional().describe(
+          "Subscribe to notifications when a delete marker for a versioned object is created."
+        )
+      }).optional().describe("Describes the store events you want to subscribe too.")
+    })
+  )
+]).optional().describe("Define the stores in your stack.");
+
+// src/feature/table/schema.ts
+import { z as z18 } from "zod";
+var KeySchema = z18.string().min(1).max(255);
+var DeletionProtectionSchema2 = z18.boolean().describe("Specifies if you want to protect the table from being deleted by awsless.");
+var TableDefaultSchema = z18.object({
+  deletionProtection: DeletionProtectionSchema2.optional()
+}).optional();
+var TablesSchema = z18.record(
+  ResourceIdSchema,
+  z18.object({
+    hash: KeySchema.describe(
+      "Specifies the name of the partition / hash key that makes up the primary key for the table."
+    ),
+    sort: KeySchema.optional().describe(
+      "Specifies the name of the range / sort key that makes up the primary key for the table."
+    ),
+    fields: z18.record(z18.string(), z18.enum(["string", "number", "binary"])).optional().describe(
+      'A list of attributes that describe the key schema for the table and indexes. If no attribute field is defined we default to "string".'
+    ),
+    class: z18.enum(["standard", "standard-infrequent-access"]).default("standard").describe("The table class of the table."),
+    pointInTimeRecovery: z18.boolean().default(false).describe("Indicates whether point in time recovery is enabled on the table."),
+    timeToLiveAttribute: KeySchema.optional().describe(
+      "The name of the TTL attribute used to store the expiration time for items in the table. To update this property, you must first disable TTL and then enable TTL with the new attribute name."
+    ),
+    deletionProtection: DeletionProtectionSchema2.optional(),
+    stream: z18.object({
+      type: z18.enum(["keys-only", "new-image", "old-image", "new-and-old-images"]).describe(
+        "When an item in the table is modified, stream.type determines what information is written to the stream for this table. Valid values are:\n- keys-only - Only the key attributes of the modified item are written to the stream.\n- new-image - The entire item, as it appears after it was modified, is written to the stream.\n- old-image - The entire item, as it appeared before it was modified, is written to the stream.\n- new-and-old-images - Both the new and the old item images of the item are written to the stream."
+      ),
+      consumer: FunctionSchema.describe("The consuming lambda function for the stream")
+    }).optional().describe(
+      "The settings for the DynamoDB table stream, which capture changes to items stored in the table."
+    ),
+    indexes: z18.record(
+      z18.string(),
+      z18.object({
+        /** Specifies the name of the partition / hash key that makes up the primary key for the global secondary index. */
+        hash: KeySchema,
+        /** Specifies the name of the range / sort key that makes up the primary key for the global secondary index. */
+        sort: KeySchema.optional(),
+        /** The set of attributes that are projected into the index:
+         * - all - All of the table attributes are projected into the index.
+         * - keys-only - Only the index and primary keys are projected into the index.
+         * @default 'all'
+         */
+        projection: z18.enum(["all", "keys-only"]).default("all")
+      })
+    ).optional().describe("Specifies the global secondary indexes to be created on the table.")
+  })
+).optional().describe("Define the tables in your stack.");
+
+// src/config/schema/region.ts
+import { z as z19 } from "zod";
 var US = ["us-east-2", "us-east-1", "us-west-1", "us-west-2"];
 var AF = ["af-south-1"];
 var AP = [
@@ -945,20 +1048,20 @@ var EU = [
 var ME = ["me-south-1", "me-central-1"];
 var SA = ["sa-east-1"];
 var regions = [...US, ...AF, ...AP, ...CA, ...EU, ...ME, ...SA];
-var RegionSchema = z17.enum(regions);
+var RegionSchema = z19.enum(regions);
 
 // src/config/app.ts
-var AppSchema = z18.object({
-  $schema: z18.string().optional(),
+var AppSchema = z20.object({
+  $schema: z20.string().optional(),
   name: ResourceIdSchema.describe("App name."),
   region: RegionSchema.describe("The AWS region to deploy to."),
-  profile: z18.string().describe("The AWS profile to deploy to."),
+  profile: z20.string().describe("The AWS profile to deploy to."),
   // stage: z
   // 	.string()
   // 	.regex(/^[a-z]+$/)
   // 	.default('prod')
   // 	.describe('The deployment stage.'),
-  defaults: z18.object({
+  defaults: z20.object({
     auth: AuthDefaultSchema,
     domains: DomainsDefaultSchema,
     function: FunctionDefaultSchema,
@@ -967,7 +1070,10 @@ var AppSchema = z18.object({
     graphql: GraphQLDefaultSchema,
     http: HttpDefaultSchema,
     rest: RestDefaultSchema,
-    pubsub: PubSubDefaultSchema
+    pubsub: PubSubDefaultSchema,
+    table: TableDefaultSchema,
+    store: StoreDefaultSchema
+    // dataRetention: z.boolean().describe('Configure how your resources are handled on delete.').default(false),
   }).default({}).describe("Default properties")
 });
 
@@ -975,8 +1081,8 @@ var AppSchema = z18.object({
 import { z as z32 } from "zod";
 
 // src/feature/cache/schema.ts
-import { z as z19 } from "zod";
-var TypeSchema2 = z19.enum([
+import { z as z21 } from "zod";
+var TypeSchema2 = z21.enum([
   "t4g.small",
   "t4g.medium",
   "r6g.large",
@@ -991,29 +1097,29 @@ var TypeSchema2 = z19.enum([
   "r6gd.4xlarge",
   "r6gd.8xlarge"
 ]);
-var PortSchema = z19.number().int().min(1).max(5e4);
-var ShardsSchema = z19.number().int().min(0).max(100);
-var ReplicasPerShardSchema = z19.number().int().min(0).max(5);
-var EngineSchema = z19.enum(["7.0", "6.2"]);
-var CachesSchema = z19.record(
+var PortSchema = z21.number().int().min(1).max(5e4);
+var ShardsSchema = z21.number().int().min(0).max(100);
+var ReplicasPerShardSchema = z21.number().int().min(0).max(5);
+var EngineSchema = z21.enum(["7.0", "6.2"]);
+var CachesSchema = z21.record(
   ResourceIdSchema,
-  z19.object({
+  z21.object({
     type: TypeSchema2.default("t4g.small"),
     port: PortSchema.default(6379),
     shards: ShardsSchema.default(1),
     replicasPerShard: ReplicasPerShardSchema.default(1),
     engine: EngineSchema.default("7.0"),
-    dataTiering: z19.boolean().default(false)
+    dataTiering: z21.boolean().default(false)
   })
 ).optional().describe("Define the caches in your stack. For access to the cache put your functions inside the global VPC.");
 
 // src/feature/command/schema.ts
-import { z as z20 } from "zod";
-var CommandSchema2 = z20.union([
-  z20.object({
+import { z as z22 } from "zod";
+var CommandSchema2 = z22.union([
+  z22.object({
     file: LocalFileSchema,
-    handler: z20.string().default("default").describe("The name of the handler that needs to run"),
-    description: z20.string().optional().describe("A description of the command")
+    handler: z22.string().default("default").describe("The name of the handler that needs to run"),
+    description: z22.string().optional().describe("A description of the command")
     // options: z.record(ResourceIdSchema, OptionSchema).optional(),
     // arguments: z.record(ResourceIdSchema, ArgumentSchema).optional(),
   }),
@@ -1023,22 +1129,22 @@ var CommandSchema2 = z20.union([
     description: void 0
   }))
 ]);
-var CommandsSchema = z20.record(ResourceIdSchema, CommandSchema2).optional().describe("Define the custom commands for your stack.");
+var CommandsSchema = z22.record(ResourceIdSchema, CommandSchema2).optional().describe("Define the custom commands for your stack.");
 
 // src/feature/config/schema.ts
-import { z as z21 } from "zod";
-var ConfigNameSchema = z21.string().regex(/[a-z0-9\-]/g, "Invalid config name");
-var ConfigsSchema = z21.array(ConfigNameSchema).optional().describe("Define the config values for your stack.");
+import { z as z23 } from "zod";
+var ConfigNameSchema = z23.string().regex(/[a-z0-9\-]/g, "Invalid config name");
+var ConfigsSchema = z23.array(ConfigNameSchema).optional().describe("Define the config values for your stack.");
 
 // src/feature/cron/schema/index.ts
-import { z as z23 } from "zod";
+import { z as z25 } from "zod";
 
 // src/feature/cron/schema/schedule.ts
-import { z as z22 } from "zod";
+import { z as z24 } from "zod";
 import { awsCronExpressionValidator } from "aws-cron-expression-validator";
-var RateExpressionSchema = z22.custom(
+var RateExpressionSchema = z24.custom(
   (value) => {
-    return z22.string().regex(/^[0-9]+ (seconds?|minutes?|hours?|days?)$/).refine((rate) => {
+    return z24.string().regex(/^[0-9]+ (seconds?|minutes?|hours?|days?)$/).refine((rate) => {
       const [str] = rate.split(" ");
       const number = parseInt(str);
       return number > 0;
@@ -1054,9 +1160,9 @@ var RateExpressionSchema = z22.custom(
   }
   return `rate(${rate})`;
 });
-var CronExpressionSchema = z22.custom(
+var CronExpressionSchema = z24.custom(
   (value) => {
-    return z22.string().safeParse(value).success;
+    return z24.string().safeParse(value).success;
   },
   { message: "Invalid cron expression" }
 ).superRefine((value, ctx) => {
@@ -1065,12 +1171,12 @@ var CronExpressionSchema = z22.custom(
   } catch (error) {
     if (error instanceof Error) {
       ctx.addIssue({
-        code: z22.ZodIssueCode.custom,
+        code: z24.ZodIssueCode.custom,
         message: `Invalid cron expression: ${error.message}`
       });
     } else {
       ctx.addIssue({
-        code: z22.ZodIssueCode.custom,
+        code: z24.ZodIssueCode.custom,
         message: "Invalid cron expression"
       });
     }
@@ -1081,15 +1187,15 @@ var CronExpressionSchema = z22.custom(
 var ScheduleExpressionSchema = RateExpressionSchema.or(CronExpressionSchema);
 
 // src/feature/cron/schema/index.ts
-var CronsSchema = z23.record(
+var CronsSchema = z25.record(
   ResourceIdSchema,
-  z23.object({
-    enabled: z23.boolean().default(true).describe("If the cron is enabled."),
+  z25.object({
+    enabled: z25.boolean().default(true).describe("If the cron is enabled."),
     consumer: FunctionSchema.describe("The consuming lambda function properties."),
     schedule: ScheduleExpressionSchema.describe(
       'The scheduling expression.\n\nexample: "0 20 * * ? *"\nexample: "5 minutes"'
     ),
-    payload: z23.unknown().optional().describe("The JSON payload that will be passed to the consumer.")
+    payload: z25.unknown().optional().describe("The JSON payload that will be passed to the consumer.")
   })
 ).optional().describe(`Define the cron jobs in your stack.`);
 
@@ -1100,9 +1206,9 @@ var OnFailureSchema = FunctionSchema.optional().describe(
 
 // src/feature/search/schema.ts
 import { gibibytes as gibibytes2 } from "@awsless/size";
-import { z as z24 } from "zod";
-var VersionSchema = z24.enum(["2.13", "2.11", "2.9", "2.7", "2.5", "2.3", "1.3"]);
-var TypeSchema3 = z24.enum([
+import { z as z26 } from "zod";
+var VersionSchema = z26.enum(["2.13", "2.11", "2.9", "2.7", "2.5", "2.3", "1.3"]);
+var TypeSchema3 = z26.enum([
   "t3.small",
   "t3.medium",
   "m3.medium",
@@ -1177,41 +1283,41 @@ var TypeSchema3 = z24.enum([
   "r6gd.16xlarge"
 ]);
 var StorageSizeSchema = SizeSchema.refine(sizeMin(gibibytes2(10)), "Minimum storage size is 10 GB").refine(sizeMax(gibibytes2(100)), "Maximum storage size is 100 GB").describe("The size of the function's /tmp directory. You can specify a size value from 512 MB to 10 GiB.");
-var SearchsSchema = z24.record(
+var SearchsSchema = z26.record(
   ResourceIdSchema,
-  z24.object({
+  z26.object({
     type: TypeSchema3.default("t3.small"),
-    count: z24.number().int().min(1).default(1),
+    count: z26.number().int().min(1).default(1),
     version: VersionSchema.default("2.13"),
     storage: StorageSizeSchema.default("10 GB"),
-    vpc: z24.boolean().default(false)
+    vpc: z26.boolean().default(false)
   })
 ).optional().describe("Define the search instances in your stack. Backed by OpenSearch.");
 
 // src/feature/site/schema.ts
-import { z as z25 } from "zod";
-var ErrorResponsePathSchema = z25.string().describe(
+import { z as z27 } from "zod";
+var ErrorResponsePathSchema = z27.string().describe(
   "The path to the custom error page that you want to return to the viewer when your origin returns the HTTP status code specified.\n - We recommend that you store custom error pages in an Amazon S3 bucket. If you store custom error pages on an HTTP server and the server starts to return 5xx errors, CloudFront can't get the files that you want to return to viewers because the origin server is unavailable."
 );
-var StatusCodeSchema = z25.number().int().positive().optional().describe(
+var StatusCodeSchema = z27.number().int().positive().optional().describe(
   "The HTTP status code that you want CloudFront to return to the viewer along with the custom error page. There are a variety of reasons that you might want CloudFront to return a status code different from the status code that your origin returned to CloudFront, for example:\n- Some Internet devices (some firewalls and corporate proxies, for example) intercept HTTP 4xx and 5xx and prevent the response from being returned to the viewer. If you substitute 200, the response typically won't be intercepted.\n- If you don't care about distinguishing among different client errors or server errors, you can specify 400 or 500 as the ResponseCode for all 4xx or 5xx errors.\n- You might want to return a 200 status code (OK) and static website so your customers don't know that your website is down."
 );
 var MinTTLSchema = DurationSchema.describe(
   "The minimum amount of time, that you want to cache the error response. When this time period has elapsed, CloudFront queries your origin to see whether the problem that caused the error has been resolved and the requested object is now available."
 );
-var ErrorResponseSchema = z25.union([
+var ErrorResponseSchema = z27.union([
   ErrorResponsePathSchema,
-  z25.object({
+  z27.object({
     path: ErrorResponsePathSchema,
     statusCode: StatusCodeSchema.optional(),
     minTTL: MinTTLSchema.optional()
   })
 ]).optional();
-var SitesSchema = z25.record(
+var SitesSchema = z27.record(
   ResourceIdSchema,
-  z25.object({
+  z27.object({
     domain: ResourceIdSchema.describe("The domain id to link your site with.").optional(),
-    subDomain: z25.string().optional(),
+    subDomain: z27.string().optional(),
     // bind: z
     // 	.object({
     // 		auth: z.array(ResourceIdSchema),
@@ -1234,7 +1340,7 @@ var SitesSchema = z25.record(
     // 		build: z.string().optional(),
     // 	}),
     // ]),
-    errors: z25.object({
+    errors: z27.object({
       400: ErrorResponseSchema.describe("Customize a `400 Bad Request` response."),
       403: ErrorResponseSchema.describe("Customize a `403 Forbidden` response."),
       404: ErrorResponseSchema.describe("Customize a `404 Not Found` response."),
@@ -1247,16 +1353,16 @@ var SitesSchema = z25.record(
       503: ErrorResponseSchema.describe("Customize a `503 Service Unavailable` response."),
       504: ErrorResponseSchema.describe("Customize a `504 Gateway Timeout` response.")
     }).optional().describe("Customize the error responses for specific HTTP status codes."),
-    cors: z25.object({
-      override: z25.boolean().default(false),
+    cors: z27.object({
+      override: z27.boolean().default(false),
       maxAge: DurationSchema.default("365 days"),
-      exposeHeaders: z25.string().array().optional(),
-      credentials: z25.boolean().default(false),
-      headers: z25.string().array().default(["*"]),
-      origins: z25.string().array().default(["*"]),
-      methods: z25.enum(["GET", "DELETE", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "ALL"]).array().default(["ALL"])
+      exposeHeaders: z27.string().array().optional(),
+      credentials: z27.boolean().default(false),
+      headers: z27.string().array().default(["*"]),
+      origins: z27.string().array().default(["*"]),
+      methods: z27.enum(["GET", "DELETE", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "ALL"]).array().default(["ALL"])
     }).optional().describe("Define the cors headers."),
-    security: z25.object({
+    security: z27.object({
       // contentSecurityPolicy: z.object({
       // 	override: z.boolean().default(false),
       // 	policy: z.string(),
@@ -1298,132 +1404,39 @@ var SitesSchema = z25.record(
       // 	reportUri?: string
       // }
     }).optional().describe("Define the security policy."),
-    cache: z25.object({
-      cookies: z25.string().array().optional().describe("Specifies the cookies that CloudFront includes in the cache key."),
-      headers: z25.string().array().optional().describe("Specifies the headers that CloudFront includes in the cache key."),
-      queries: z25.string().array().optional().describe("Specifies the query values that CloudFront includes in the cache key.")
+    cache: z27.object({
+      cookies: z27.string().array().optional().describe("Specifies the cookies that CloudFront includes in the cache key."),
+      headers: z27.string().array().optional().describe("Specifies the headers that CloudFront includes in the cache key."),
+      queries: z27.string().array().optional().describe("Specifies the query values that CloudFront includes in the cache key.")
     }).optional().describe(
       "Specifies the cookies, headers, and query values that CloudFront includes in the cache key."
     )
   })
 ).optional().describe("Define the sites in your stack.");
 
-// src/feature/store/schema.ts
-import { z as z26 } from "zod";
-var StoresSchema = z26.union([
-  z26.array(ResourceIdSchema).transform((list4) => {
-    const stores = {};
-    for (const key of list4) {
-      stores[key] = {};
-    }
-    return stores;
-  }),
-  z26.record(
-    ResourceIdSchema,
-    z26.object({
-      // cors: CorsSchema,
-      versioning: z26.boolean().default(false).describe("Enable versioning of your store."),
-      events: z26.object({
-        // create
-        "created:*": FunctionSchema.optional().describe(
-          "Subscribe to notifications regardless of the API that was used to create an object."
-        ),
-        "created:put": FunctionSchema.optional().describe(
-          "Subscribe to notifications when an object is created using the PUT API operation."
-        ),
-        "created:post": FunctionSchema.optional().describe(
-          "Subscribe to notifications when an object is created using the POST API operation."
-        ),
-        "created:copy": FunctionSchema.optional().describe(
-          "Subscribe to notifications when an object is created using the COPY API operation."
-        ),
-        "created:upload": FunctionSchema.optional().describe(
-          "Subscribe to notifications when an object multipart upload has been completed."
-        ),
-        // remove
-        "removed:*": FunctionSchema.optional().describe(
-          "Subscribe to notifications when an object is deleted or a delete marker for a versioned object is created."
-        ),
-        "removed:delete": FunctionSchema.optional().describe(
-          "Subscribe to notifications when an object is deleted"
-        ),
-        "removed:marker": FunctionSchema.optional().describe(
-          "Subscribe to notifications when a delete marker for a versioned object is created."
-        )
-      }).optional().describe("Describes the store events you want to subscribe too.")
-    })
-  )
-]).optional().describe("Define the stores in your stack.");
-
 // src/feature/stream/schema.ts
-import { z as z27 } from "zod";
-var LatencyModeSchema = z27.enum(["low", "normal"]).describe(
+import { z as z28 } from "zod";
+var LatencyModeSchema = z28.enum(["low", "normal"]).describe(
   `Channel latency mode. Valid values:
 - normal: Use "normal" to broadcast and deliver live video up to Full HD.
 - low: Use "low" for near real-time interactions with viewers.`
 );
-var TypeSchema4 = z27.enum(["standard", "basic", "advanced-sd", "advanced-hd"]).describe(`The channel type, which determines the allowable resolution and bitrate.
+var TypeSchema4 = z28.enum(["standard", "basic", "advanced-sd", "advanced-hd"]).describe(`The channel type, which determines the allowable resolution and bitrate.
 If you exceed the allowable resolution or bitrate, the stream probably will disconnect immediately. Valid values:
 - standard: Video is transcoded: multiple qualities are generated from the original input to automatically give viewers the best experience for their devices and network conditions. Transcoding allows higher playback quality across a range of download speeds. Resolution can be up to 1080p and bitrate can be up to 8.5 Mbps. Audio is transcoded only for renditions 360p and below; above that, audio is passed through.
 - basic: Video is transmuxed: Amazon IVS delivers the original input to viewers. The viewer's video-quality choice is limited to the original input. Resolution can be up to 1080p and bitrate can be up to 1.5 Mbps for 480p and up to 3.5 Mbps for resolutions between 480p and 1080p.
 - advanced-sd: Video is transcoded; multiple qualities are generated from the original input, to automatically give viewers the best experience for their devices and network conditions. Input resolution can be up to 1080p and bitrate can be up to 8.5 Mbps; output is capped at SD quality (480p). You can select an optional transcode preset (see below). Audio for all renditions is transcoded, and an audio-only rendition is available.
 - advanced-hd: Video is transcoded; multiple qualities are generated from the original input, to automatically give viewers the best experience for their devices and network conditions. Input resolution can be up to 1080p and bitrate can be up to 8.5 Mbps; output is capped at HD quality (720p). You can select an optional transcode preset (see below). Audio for all renditions is transcoded, and an audio-only rendition is available.
 `);
-var StreamsSchema = z27.record(
+var StreamsSchema = z28.record(
   ResourceIdSchema,
-  z27.object({
+  z28.object({
     type: TypeSchema4.default("standard"),
     // preset: PresetSchema.optional(),
     latencyMode: LatencyModeSchema.default("low")
   })
 ).optional().describe("Define the streams in your stack.");
 
-// src/feature/table/schema.ts
-import { z as z28 } from "zod";
-var KeySchema = z28.string().min(1).max(255);
-var TablesSchema = z28.record(
-  ResourceIdSchema,
-  z28.object({
-    hash: KeySchema.describe(
-      "Specifies the name of the partition / hash key that makes up the primary key for the table."
-    ),
-    sort: KeySchema.optional().describe(
-      "Specifies the name of the range / sort key that makes up the primary key for the table."
-    ),
-    fields: z28.record(z28.string(), z28.enum(["string", "number", "binary"])).optional().describe(
-      'A list of attributes that describe the key schema for the table and indexes. If no attribute field is defined we default to "string".'
-    ),
-    class: z28.enum(["standard", "standard-infrequent-access"]).default("standard").describe("The table class of the table."),
-    pointInTimeRecovery: z28.boolean().default(false).describe("Indicates whether point in time recovery is enabled on the table."),
-    timeToLiveAttribute: KeySchema.optional().describe(
-      "The name of the TTL attribute used to store the expiration time for items in the table. To update this property, you must first disable TTL and then enable TTL with the new attribute name."
-    ),
-    stream: z28.object({
-      type: z28.enum(["keys-only", "new-image", "old-image", "new-and-old-images"]).describe(
-        "When an item in the table is modified, stream.type determines what information is written to the stream for this table. Valid values are:\n- keys-only - Only the key attributes of the modified item are written to the stream.\n- new-image - The entire item, as it appears after it was modified, is written to the stream.\n- old-image - The entire item, as it appeared before it was modified, is written to the stream.\n- new-and-old-images - Both the new and the old item images of the item are written to the stream."
-      ),
-      consumer: FunctionSchema.describe("The consuming lambda function for the stream")
-    }).optional().describe(
-      "The settings for the DynamoDB table stream, which capture changes to items stored in the table."
-    ),
-    indexes: z28.record(
-      z28.string(),
-      z28.object({
-        /** Specifies the name of the partition / hash key that makes up the primary key for the global secondary index. */
-        hash: KeySchema,
-        /** Specifies the name of the range / sort key that makes up the primary key for the global secondary index. */
-        sort: KeySchema.optional(),
-        /** The set of attributes that are projected into the index:
-         * - all - All of the table attributes are projected into the index.
-         * - keys-only - Only the index and primary keys are projected into the index.
-         * @default 'all'
-         */
-        projection: z28.enum(["all", "keys-only"]).default("all")
-      })
-    ).optional().describe("Specifies the global secondary indexes to be created on the table.")
-  })
-).optional().describe("Define the tables in your stack.");
-
 // src/feature/task/schema.ts
 import { z as z29 } from "zod";
 var RetryAttemptsSchema2 = z29.number().int().min(0).max(2).describe(
@@ -1958,22 +1971,30 @@ var TypeObject = class {
 
 // src/util/name.ts
 import { paramCase as paramCase3 } from "change-case";
-var formatGlobalResourceName = (appName, ns, id, seperator = "--") => {
+import { createHmac } from "crypto";
+var formatGlobalResourceName = (opt) => {
   return [
     //
-    appName,
-    ns,
-    id
-  ].map((v) => paramCase3(v)).join(seperator);
+    opt.prefix,
+    opt.appName,
+    opt.resourceType,
+    opt.resourceName,
+    opt.postfix
+  ].filter((v) => typeof v === "string").map((v) => paramCase3(v)).join(opt.seperator ?? "--");
 };
-var formatLocalResourceName = (appName, stackName, ns, id, seperator = "--") => {
+var formatLocalResourceName = (opt) => {
   return [
     //
-    appName,
-    stackName,
-    ns,
-    id
-  ].map((v) => paramCase3(v)).join(seperator);
+    opt.prefix,
+    opt.appName,
+    opt.stackName,
+    opt.resourceType,
+    opt.resourceName,
+    opt.postfix
+  ].filter((v) => typeof v === "string").map((v) => paramCase3(v)).join(opt.seperator ?? "--");
+};
+var generateGlobalAppId = (opt) => {
+  return createHmac("sha1", "awsless").update(opt.accountId).update(opt.region).update(opt.appName).digest("hex").substring(0, 8);
 };
 
 // src/feature/function/util.ts
@@ -2173,10 +2194,19 @@ var zipFiles = (files) => {
 import { hashElement } from "folder-hash";
 var createLambdaFunction = (group, ctx, ns, id, local2) => {
   let name;
-  if ("stackConfig" in ctx) {
-    name = formatLocalResourceName(ctx.appConfig.name, ctx.stackConfig.name, ns, id);
+  if ("stack" in ctx) {
+    name = formatLocalResourceName({
+      appName: ctx.app.name,
+      stackName: ctx.stack.name,
+      resourceType: ns,
+      resourceName: id
+    });
   } else {
-    name = formatGlobalResourceName(ctx.appConfig.name, ns, id);
+    name = formatGlobalResourceName({
+      appName: ctx.appConfig.name,
+      resourceType: ns,
+      resourceName: id
+    });
   }
   const props = deepmerge(ctx.appConfig.defaults.function, local2);
   let code;
@@ -2190,7 +2220,12 @@ var createLambdaFunction = (group, ctx, ns, id, local2) => {
         }
       });
       return build3(version.hash + props.architecture, async (write) => {
-        const repoName = formatGlobalResourceName(ctx.appConfig.name, "function", "repository", "-");
+        const repoName = formatGlobalResourceName({
+          appName: ctx.app.name,
+          resourceType: "function",
+          resourceName: "repository",
+          seperator: "-"
+        });
         const platform = props.architecture === "arm64" ? "linux/arm64" : "linux/amd64";
         await exec(`docker buildx build --platform ${platform} -t ${name} .`, {
           cwd: basePath2
@@ -2277,6 +2312,7 @@ var createLambdaFunction = (group, ctx, ns, id, local2) => {
   });
   ctx.registerPolicy(policy);
   lambda.addEnvironment("APP", ctx.appConfig.name);
+  lambda.addEnvironment("APP_ID", ctx.appId);
   if ("stackConfig" in ctx) {
     lambda.addEnvironment("STACK", ctx.stackConfig.name);
   }
@@ -2457,7 +2493,11 @@ var authFeature = defineFeature({
           from: props.messaging.fromName ? `${props.messaging.fromName} <${props.messaging.fromEmail}>` : props.messaging.fromEmail
         };
       }
-      const name = formatGlobalResourceName(ctx.appConfig.name, "auth", id);
+      const name = formatGlobalResourceName({
+        appName: ctx.app.name,
+        resourceType: "auth",
+        resourceName: id
+      });
       const userPool = new aws3.cognito.UserPool(group, "user-pool", {
         name,
         // deletionProtection: true,
@@ -2517,7 +2557,13 @@ var cacheFeature = defineFeature({
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.caches ?? {})) {
       const group = new Node3(ctx.stack, this.name, id);
-      const name = formatLocalResourceName(ctx.appConfig.name, ctx.stack.name, this.name, id, "-");
+      const name = formatLocalResourceName({
+        appName: ctx.app.name,
+        stackName: ctx.stack.name,
+        resourceType: "cache",
+        resourceName: id,
+        seperator: "-"
+      });
       const subnetGroup = new aws4.memorydb.SubnetGroup(group, "subnets", {
         name,
         subnetIds: [
@@ -2715,7 +2761,12 @@ var cronFeature = defineFeature({
       const group = new Node4(ctx.stack, "cron", id);
       const { lambda } = createAsyncLambdaFunction(group, ctx, "cron", id, props.consumer);
       const rule = new aws5.events.Rule(group, "rule", {
-        name: formatLocalResourceName(ctx.app.name, ctx.stack.name, this.name, id),
+        name: formatLocalResourceName({
+          appName: ctx.app.name,
+          stackName: ctx.stack.name,
+          resourceType: "cron",
+          resourceName: id
+        }),
         schedule: props.schedule,
         enabled: props.enabled,
         targets: [
@@ -2889,7 +2940,12 @@ var functionFeature = defineFeature({
       for (const [name, local2] of Object.entries(stack.functions || {})) {
         const props = deepmerge2(ctx.appConfig.defaults.function, local2);
         const varName = camelCase3(`${stack.name}-${name}`);
-        const funcName = formatLocalResourceName(ctx.appConfig.name, stack.name, "function", name);
+        const funcName = formatLocalResourceName({
+          appName: ctx.appConfig.name,
+          stackName: stack.name,
+          resourceType: "function",
+          resourceName: name
+        });
         const relFile = relative(directories.types, props.file);
         if (props.runtime === "container") {
           resource2.addType(name, `Invoke<'${funcName}', Func>`);
@@ -2915,13 +2971,23 @@ var functionFeature = defineFeature({
   onApp(ctx) {
     const group = new Node6(ctx.base, "function", "asset");
     const bucket = new aws7.s3.Bucket(group, "bucket", {
-      name: formatGlobalResourceName(ctx.appConfig.name, "function", "assets"),
+      name: formatGlobalResourceName({
+        appName: ctx.app.name,
+        resourceType: "function",
+        resourceName: "assets",
+        postfix: ctx.appId
+      }),
       versioning: true,
       forceDelete: true
     });
     ctx.shared.set("function-bucket-name", bucket.name);
     const repository = new aws7.ecr.Repository(group, "repository", {
-      name: formatGlobalResourceName(ctx.appConfig.name, "function", "repository", "-"),
+      name: formatGlobalResourceName({
+        appName: ctx.app.name,
+        resourceType: "function",
+        resourceName: "repository",
+        seperator: "-"
+      }),
       imageTagMutability: true
     });
     ctx.shared.set("function-repository-name", repository.name);
@@ -3125,7 +3191,11 @@ var graphqlFeature = defineFeature({
         const { lambda } = createLambdaFunction(group, ctx, "graphql-auth", id, props.auth.authorizer);
         authorizer = lambda;
       }
-      const name = formatGlobalResourceName(ctx.app.name, "graphql", id);
+      const name = formatGlobalResourceName({
+        appName: ctx.app.name,
+        resourceType: "graphql",
+        resourceName: id
+      });
       const api = new aws8.appsync.GraphQLApi(group, "api", {
         name,
         type: "graphql",
@@ -3379,7 +3449,11 @@ var httpFeature = defineFeature({
     const group = new Node8(ctx.base, "http", "main");
     const securityGroup = new aws9.ec2.SecurityGroup(group, "http", {
       vpcId: ctx.shared.get(`vpc-id`),
-      name: formatGlobalResourceName(ctx.app.name, "http", "http"),
+      name: formatGlobalResourceName({
+        appName: ctx.app.name,
+        resourceType: "http",
+        resourceName: "http"
+      }),
       description: `Global security group for HTTP api.`
     });
     const port = aws9.ec2.Port.tcp(443);
@@ -3388,7 +3462,11 @@ var httpFeature = defineFeature({
     for (const [id, props] of Object.entries(ctx.appConfig.defaults?.http ?? {})) {
       const group2 = new Node8(ctx.base, "http", id);
       const loadBalancer = new aws9.elb.LoadBalancer(group2, "balancer", {
-        name: formatGlobalResourceName(ctx.app.name, "http", id),
+        name: formatGlobalResourceName({
+          appName: ctx.app.name,
+          resourceType: "http",
+          resourceName: id
+        }),
         type: "application",
         securityGroups: [securityGroup.id],
         subnets: [
@@ -3442,7 +3520,12 @@ var httpFeature = defineFeature({
           ...routeProps,
           description: routeKey
         });
-        const name = formatLocalResourceName(ctx.app.name, ctx.stack.name, "http", routeId);
+        const name = formatLocalResourceName({
+          appName: ctx.app.name,
+          stackName: ctx.stack.name,
+          resourceType: "http",
+          resourceName: routeId
+        });
         const permission = new aws9.lambda.Permission(routeGroup, id, {
           action: "lambda:InvokeFunction",
           principal: "elasticloadbalancing.amazonaws.com",
@@ -3480,13 +3563,18 @@ var instanceFeature = defineFeature({
   onApp(ctx) {
     const group = new Node9(ctx.base, "instance", "asset");
     const bucket = new aws10.s3.Bucket(group, "bucket", {
-      name: formatGlobalResourceName(ctx.appConfig.name, "instance", "assets"),
+      name: formatGlobalResourceName({
+        appName: ctx.app.name,
+        resourceType: "instance",
+        resourceName: "assets",
+        postfix: ctx.appId
+      }),
       forceDelete: true
     });
     ctx.shared.set("instance-bucket-name", bucket.name);
     if (ctx.appConfig.defaults.instance.connect) {
       new aws10.ec2.InstanceConnectEndpoint(group, "connect", {
-        name: ctx.appConfig.name,
+        name: ctx.app.name,
         subnetId: ctx.shared.get(`vpc-public-subnet-id-1`),
         securityGroupIds: [ctx.shared.get("vpc-security-group-id")]
       });
@@ -3495,10 +3583,16 @@ var instanceFeature = defineFeature({
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.instances ?? {})) {
       const group = new Node9(ctx.stack, "instance", id);
-      const name = formatLocalResourceName(ctx.appConfig.name, ctx.stack.name, "instance", id);
+      const name = formatLocalResourceName({
+        appName: ctx.app.name,
+        stackName: ctx.stack.name,
+        resourceType: "instance",
+        resourceName: id
+      });
       const env = {
-        APP: ctx.appConfig.name,
-        STACK: ctx.stackConfig.name
+        APP: ctx.app.name,
+        APP_ID: ctx.appId,
+        STACK: ctx.stack.name
       };
       ctx.onEnv((name2, value) => {
         env[name2] = value;
@@ -3621,7 +3715,11 @@ var onFailureFeature = defineFeature({
       throw new TypeError("Only 1 onFailure configuration is allowed in your app.");
     }
     const queue2 = new aws11.sqs.Queue(ctx.base, "on-failure", {
-      name: formatGlobalResourceName(ctx.appConfig.name, "on-failure", "failure")
+      name: formatGlobalResourceName({
+        appName: ctx.app.name,
+        resourceType: "on-failure",
+        resourceName: "failure"
+      })
     });
     ctx.shared.set("on-failure-queue-arn", queue2.arn);
   },
@@ -3664,7 +3762,11 @@ var pubsubFeature = defineFeature({
       const { lambda } = createLambdaFunction(group, ctx, "pubsub-authorizer", id, functionProps);
       lambda.addEnvironment("PUBSUB_POLICY", JSON.stringify(props.policy));
       lambda.addEnvironment("AWS_ACCOUNT_ID", ctx.accountId);
-      const name = formatGlobalResourceName(ctx.app.name, "pubsub", id);
+      const name = formatGlobalResourceName({
+        appName: ctx.app.name,
+        resourceType: "pubsub",
+        resourceName: id
+      });
       const authorizer = new aws12.iot.Authorizer(group, "authorizer", {
         name,
         functionArn: lambda.arn
@@ -3713,7 +3815,12 @@ var pubsubFeature = defineFeature({
     for (const [id, props] of Object.entries(ctx.stackConfig.pubsub ?? {})) {
       const group = new Node11(ctx.stack, "pubsub", id);
       const { lambda } = createAsyncLambdaFunction(group, ctx, `pubsub`, id, props.consumer);
-      const name = formatLocalResourceName(ctx.app.name, ctx.stack.name, "pubsub", id);
+      const name = formatLocalResourceName({
+        appName: ctx.app.name,
+        stackName: ctx.stack.name,
+        resourceType: "pubsub",
+        resourceName: id
+      });
       const topic = new aws12.iot.TopicRule(group, "rule", {
         name: name.replaceAll("-", "_"),
         sql: props.sql,
@@ -3765,7 +3872,12 @@ var queueFeature = defineFeature({
       const mockResponse = new TypeObject(2);
       for (const [name, fileOrProps] of Object.entries(stack.queues || {})) {
         const varName = camelCase5(`${stack.name}-${name}`);
-        const queueName = formatLocalResourceName(ctx.appConfig.name, stack.name, "queue", name);
+        const queueName = formatLocalResourceName({
+          appName: ctx.appConfig.name,
+          stackName: stack.name,
+          resourceType: "queue",
+          resourceName: name
+        });
         const file = typeof fileOrProps === "string" ? fileOrProps : typeof fileOrProps.consumer === "string" ? fileOrProps.consumer : fileOrProps.consumer.file;
         const relFile = relative3(directories.types, file);
         gen.addImport(varName, relFile);
@@ -3787,8 +3899,14 @@ var queueFeature = defineFeature({
     for (const [id, local2] of Object.entries(ctx.stackConfig.queues || {})) {
       const props = deepmerge3(ctx.appConfig.defaults.queue, local2);
       const group = new Node12(ctx.stack, "queue", id);
+      const name = formatLocalResourceName({
+        appName: ctx.app.name,
+        stackName: ctx.stack.name,
+        resourceType: "queue",
+        resourceName: id
+      });
       const queue2 = new aws13.sqs.Queue(group, "queue", {
-        name: formatLocalResourceName(ctx.appConfig.name, ctx.stack.name, "queue", id),
+        name,
         deadLetterArn: getGlobalOnFailure(ctx),
         ...props
       });
@@ -3821,8 +3939,13 @@ var restFeature = defineFeature({
   onApp(ctx) {
     for (const [id, props] of Object.entries(ctx.appConfig.defaults?.rest ?? {})) {
       const group = new Node13(ctx.base, "rest", id);
+      const name = formatGlobalResourceName({
+        appName: ctx.app.name,
+        resourceType: "rest",
+        resourceName: id
+      });
       const api = new aws14.apiGatewayV2.Api(group, "api", {
-        name: formatGlobalResourceName(ctx.app.name, "rest", id),
+        name,
         protocolType: "HTTP"
       });
       const stage = new aws14.apiGatewayV2.Stage(group, "stage", {
@@ -4002,7 +4125,12 @@ var siteFeature = defineFeature({
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.sites ?? {})) {
       const group = new Node15(ctx.stack, "site", id);
-      const name = formatLocalResourceName(ctx.app.name, ctx.stack.name, "site", id);
+      const name = formatLocalResourceName({
+        appName: ctx.app.name,
+        stackName: ctx.stack.name,
+        resourceType: "site",
+        resourceName: id
+      });
       const origins = [];
       const originGroups = [];
       let bucket;
@@ -4037,7 +4165,13 @@ var siteFeature = defineFeature({
       }
       if (props.static) {
         bucket = new aws16.s3.Bucket(group, "bucket", {
-          name,
+          name: formatLocalResourceName({
+            appName: ctx.app.name,
+            stackName: ctx.stack.name,
+            resourceType: "site",
+            resourceName: id,
+            postfix: ctx.appId
+          }),
           forceDelete: true,
           website: {
             indexDocument: "index.html",
@@ -4213,7 +4347,12 @@ var storeFeature = defineFeature({
     for (const stack of ctx.stackConfigs) {
       const list4 = new TypeObject(2);
       for (const id of Object.keys(stack.stores ?? {})) {
-        const storeName = formatLocalResourceName(ctx.appConfig.name, stack.name, "store", id);
+        const storeName = formatLocalResourceName({
+          appName: ctx.appConfig.name,
+          stackName: stack.name,
+          resourceType: "store",
+          resourceName: id
+        });
         list4.addType(id, `Store<'${storeName}'>`);
       }
       resources.addType(stack.name, list4);
@@ -4222,10 +4361,19 @@ var storeFeature = defineFeature({
     gen.addInterface("StoreResources", resources);
     await ctx.write("store.d.ts", gen, true);
   },
+  onApp(ctx) {
+    ctx.addEnv("STORE_POSTFIX", ctx.appId);
+  },
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.stores ?? {})) {
       const group = new Node16(ctx.stack, "store", id);
-      const bucketName = formatLocalResourceName(ctx.appConfig.name, ctx.stack.name, "store", id);
+      const name = formatLocalResourceName({
+        appName: ctx.app.name,
+        stackName: ctx.stack.name,
+        resourceType: "store",
+        resourceName: id,
+        postfix: ctx.appId
+      });
       const lambdaConfigs = [];
       const eventMap = {
         "created:*": "s3:ObjectCreated:*",
@@ -4248,7 +4396,7 @@ var storeFeature = defineFeature({
           action: "lambda:InvokeFunction",
           principal: "s3.amazonaws.com",
           functionArn: lambda.arn,
-          sourceArn: `arn:aws:s3:::${bucketName}`
+          sourceArn: `arn:aws:s3:::${name}`
         });
         lambdaConfigs.push({
           event: eventMap[event],
@@ -4256,7 +4404,7 @@ var storeFeature = defineFeature({
         });
       }
       const bucket = new aws17.s3.Bucket(group, "store", {
-        name: bucketName,
+        name,
         versioning: props.versioning,
         forceDelete: true,
         lambdaConfigs,
@@ -4271,6 +4419,10 @@ var storeFeature = defineFeature({
           // ---------------------------------------------
         ]
       });
+      const deletionProtection = props.deletionProtection ?? ctx.appConfig.defaults.store?.deletionProtection;
+      if (deletionProtection) {
+        bucket.deletionPolicy = "retain";
+      }
       ctx.onPolicy((policy) => {
         policy.addStatement(bucket.permissions);
       });
@@ -4286,7 +4438,12 @@ var streamFeature = defineFeature({
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.streams ?? {})) {
       const group = new Node17(ctx.stack, "stream", id);
-      const name = formatLocalResourceName(ctx.appConfig.name, ctx.stack.name, "stream", id);
+      const name = formatLocalResourceName({
+        appName: ctx.app.name,
+        stackName: ctx.stack.name,
+        resourceType: "stream",
+        resourceName: id
+      });
       const channel = new aws18.ivs.Channel(group, "channel", {
         name,
         ...props
@@ -4312,7 +4469,12 @@ var tableFeature = defineFeature({
     for (const stack of ctx.stackConfigs) {
       const list4 = new TypeObject(2);
       for (const name of Object.keys(stack.tables || {})) {
-        const tableName = formatLocalResourceName(ctx.appConfig.name, stack.name, "table", name);
+        const tableName = formatLocalResourceName({
+          appName: ctx.appConfig.name,
+          stackName: stack.name,
+          resourceType: "table",
+          resourceName: name
+        });
         list4.addType(name, `'${tableName}'`);
       }
       resources.addType(stack.name, list4);
@@ -4323,11 +4485,22 @@ var tableFeature = defineFeature({
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.tables ?? {})) {
       const group = new Node18(ctx.stack, "table", id);
+      const name = formatLocalResourceName({
+        appName: ctx.app.name,
+        stackName: ctx.stack.name,
+        resourceType: "table",
+        resourceName: id
+      });
+      const deletionProtection = props.deletionProtection ?? ctx.appConfig.defaults.table?.deletionProtection;
       const table2 = new aws19.dynamodb.Table(group, "table", {
         ...props,
-        name: formatLocalResourceName(ctx.appConfig.name, ctx.stackConfig.name, "table", id),
-        stream: props.stream?.type
+        name,
+        stream: props.stream?.type,
+        deletionProtection
       });
+      if (deletionProtection) {
+        table2.deletionPolicy = "retain";
+      }
       if (props.stream) {
         const { lambda, policy } = createLambdaFunction(group, ctx, "table", id, props.stream.consumer);
         lambda.addEnvironment("LOG_VIEWABLE_ERROR", "1");
@@ -4397,7 +4570,12 @@ var taskFeature = defineFeature({
       const mockResponse = new TypeObject(2);
       for (const [name, props] of Object.entries(stack.tasks || {})) {
         const varName = camelCase6(`${stack.name}-${name}`);
-        const funcName = formatLocalResourceName(ctx.appConfig.name, stack.name, "task", name);
+        const funcName = formatLocalResourceName({
+          appName: ctx.appConfig.name,
+          stackName: stack.name,
+          resourceType: "task",
+          resourceName: name
+        });
         const relFile = relative4(directories.types, props.consumer.file);
         types2.addImport(varName, relFile);
         resource2.addType(name, `Invoke<'${funcName}', typeof ${varName}>`);
@@ -4455,7 +4633,11 @@ var topicFeature = defineFeature({
     const mockResponses = new TypeObject(1);
     for (const stack of ctx.stackConfigs) {
       for (const topic of stack.topics || []) {
-        const name = formatGlobalResourceName(ctx.appConfig.name, "topic", topic);
+        const name = formatGlobalResourceName({
+          appName: ctx.appConfig.name,
+          resourceType: "topic",
+          resourceName: topic
+        });
         mockResponses.addType(topic, "Mock");
         resources.addType(topic, `Publish<'${name}'>`);
         mocks.addType(topic, `MockBuilder`);
@@ -4471,8 +4653,13 @@ var topicFeature = defineFeature({
     for (const stack of ctx.stackConfigs) {
       for (const id of stack.topics ?? []) {
         const group = new Node20(ctx.base, "topic", id);
+        const name = formatGlobalResourceName({
+          appName: ctx.appConfig.name,
+          resourceType: "topic",
+          resourceName: id
+        });
         const topic = new aws20.sns.Topic(group, "topic", {
-          name: formatGlobalResourceName(ctx.appConfig.name, "topic", id)
+          name
         });
         ctx.shared.set(`topic-${id}-arn`, topic.arn);
       }
@@ -4656,6 +4843,11 @@ var createApp = (props, filters = []) => {
   const app = new App2(props.appConfig.name);
   const base = new Stack(app, "base");
   const shared = new SharedData();
+  const appId = generateGlobalAppId({
+    accountId: props.accountId,
+    region: props.appConfig.region,
+    appName: props.appConfig.name
+  });
   const commands7 = [];
   const configs = /* @__PURE__ */ new Set();
   const tests = [];
@@ -4678,6 +4870,7 @@ var createApp = (props, filters = []) => {
     feature.onApp?.({
       ...props,
       app,
+      appId,
       // env,
       base,
       shared,
@@ -4742,6 +4935,7 @@ var createApp = (props, filters = []) => {
         ...props,
         stackConfig,
         app,
+        appId,
         // env,
         base,
         stack,