The best way to control Claude Code, Codex and more from any computer or phone

main
ts 617 lines 23.2 KB
Raw
1 import * as efs from "@distilled.cloud/aws/efs";
2 import { Unowned } from "alchemy/AdoptPolicy";
3 import { isResolved } from "alchemy/Diff";
4 import { createPhysicalName } from "alchemy/PhysicalName";
5 import * as Provider from "alchemy/Provider";
6 import { Resource } from "alchemy/Resource";
7 import { createInternalTags, diffTags, hasAlchemyTags } from "alchemy/Tags";
8 import * as Data from "effect/Data";
9 import * as Effect from "effect/Effect";
10 import * as Schedule from "effect/Schedule";
11 import * as Stream from "effect/Stream";
12 import { AWSEnvironment } from "../Environment.ts";
13 import {
14 normalizePolicyDocument,
15 type PolicyDocument,
16 stringifyPolicyDocument,
17 } from "../IAM/Policy.ts";
18 import type { Providers } from "../Providers.ts";
19
20 /**
21 * A single EFS lifecycle-management rule. EFS requires each rule to carry
22 * exactly one transition setting, so a full configuration is expressed as an
23 * array of single-setting policies.
24 */
25 export interface FileSystemLifecyclePolicy {
26 /**
27 * Transition files to the Infrequent Access (IA) storage class after the
28 * given period without access, e.g. `"AFTER_30_DAYS"`.
29 */
30 transitionToIA?: efs.TransitionToIARules;
31 /**
32 * Transition files back to primary storage on first access, e.g.
33 * `"AFTER_1_ACCESS"`.
34 */
35 transitionToPrimaryStorageClass?: efs.TransitionToPrimaryStorageClassRules;
36 /**
37 * Transition files to the Archive storage class after the given period
38 * without access, e.g. `"AFTER_90_DAYS"`.
39 */
40 transitionToArchive?: efs.TransitionToArchiveRules;
41 }
42
43 export interface FileSystemProps {
44 /**
45 * Performance mode of the file system. `generalPurpose` is recommended for
46 * all workloads; `maxIO` is a previous-generation mode for highly
47 * parallelized workloads. Cannot be changed after creation (replacement).
48 * `maxIO` is not supported with `elastic` throughput or One Zone file
49 * systems.
50 * @default "generalPurpose"
51 */
52 performanceMode?: "generalPurpose" | "maxIO";
53 /**
54 * Whether the file system is encrypted at rest. Cannot be changed after
55 * creation (replacement).
56 * @default true
57 */
58 encrypted?: boolean;
59 /**
60 * The KMS key used to encrypt the file system. Only meaningful when
61 * `encrypted` is `true`. Cannot be changed after creation (replacement).
62 * @default the AWS-managed `/aws/elasticfilesystem` key
63 */
64 kmsKeyId?: string;
65 /**
66 * Throughput mode of the file system. `elastic` scales automatically and is
67 * recommended for spiky workloads; `provisioned` requires
68 * `provisionedThroughputInMibps`. Updatable in place.
69 * @default "bursting"
70 */
71 throughputMode?: "bursting" | "provisioned" | "elastic";
72 /**
73 * Provisioned throughput in MiB/s. Required when `throughputMode` is
74 * `provisioned`.
75 */
76 provisionedThroughputInMibps?: number;
77 /**
78 * Create a One Zone file system in this Availability Zone (e.g.
79 * `us-west-2a`). Cannot be changed after creation (replacement).
80 * @default regional (multi-AZ) file system
81 */
82 availabilityZoneName?: string;
83 /**
84 * Lifecycle management rules that transition files between storage
85 * classes. Omit (or pass an empty array) to disable lifecycle management.
86 */
87 lifecyclePolicies?: FileSystemLifecyclePolicy[];
88 /**
89 * Whether AWS Backup automatic backups are enabled for the file system.
90 * Updatable in place. When omitted, the AWS default is left alone
91 * (disabled for regional file systems, enabled for One Zone file
92 * systems).
93 * @default AWS default (regional: disabled; One Zone: enabled)
94 */
95 backup?: boolean;
96 /**
97 * Replication overwrite protection. `ENABLED` (the AWS default) makes the
98 * file system writable and blocks it from being used as a replication
99 * destination; `DISABLED` makes it read-only so an EFS replication
100 * configuration can overwrite it. Updatable in place. When omitted, the
101 * current protection setting is left alone.
102 * @default AWS default ("ENABLED")
103 */
104 replicationOverwriteProtection?: "ENABLED" | "DISABLED";
105 /**
106 * The file system policy — an IAM resource-based policy controlling client
107 * access to the file system (e.g. enforcing in-transit encryption or
108 * restricting mounts to access points). Either a structured
109 * {@link PolicyDocument} or a raw JSON string. Omitting the property
110 * removes any explicit policy, reverting to the default EFS policy.
111 */
112 policy?: PolicyDocument | string;
113 /**
114 * Tags to apply to the file system. Merged with internal Alchemy tags.
115 */
116 tags?: Record<string, string>;
117 }
118
119 export interface FileSystem extends Resource<
120 "AWS.EFS.FileSystem",
121 FileSystemProps,
122 {
123 /** The ID of the file system (e.g. `fs-0123456789abcdef0`). */
124 fileSystemId: string;
125 /** The ARN of the file system. */
126 fileSystemArn: string;
127 },
128 {},
129 Providers
130 > {}
131
132 /**
133 * An Amazon EFS file system — serverless, elastic, shared POSIX storage.
134 *
135 * The file system is created encrypted by default with a deterministic
136 * creation token derived from the app, stage, and logical ID, so retried
137 * creates are idempotent. Mount it into compute with
138 * {@link MountTarget} (per-subnet network endpoints) and
139 * {@link AccessPoint} (application-specific POSIX entry points — required
140 * for Lambda mounts).
141 * ### Creating File Systems
142 * **Example:** Default file system (encrypted, general purpose)
143 * ```typescript
144 * import * as AWS from "@alchemy.run/aws";
145 *
146 * const files = yield* AWS.EFS.FileSystem("Files");
147 * ```
148 *
149 * **Example:** Elastic throughput
150 * ```typescript
151 * const files = yield* AWS.EFS.FileSystem("Files", {
152 * throughputMode: "elastic",
153 * });
154 * ```
155 *
156 * ### Lifecycle Management
157 * **Example:** Tier cold files to Infrequent Access
158 * ```typescript
159 * const files = yield* AWS.EFS.FileSystem("Files", {
160 * lifecyclePolicies: [
161 * { transitionToIA: "AFTER_30_DAYS" },
162 * { transitionToPrimaryStorageClass: "AFTER_1_ACCESS" },
163 * ],
164 * });
165 * ```
166 *
167 * ### Backup and Protection
168 * **Example:** Enable AWS Backup automatic backups
169 * ```typescript
170 * const files = yield* AWS.EFS.FileSystem("Files", {
171 * backup: true,
172 * });
173 * ```
174 *
175 * **Example:** Allow the file system to be a replication destination
176 * ```typescript
177 * const files = yield* AWS.EFS.FileSystem("Files", {
178 * replicationOverwriteProtection: "DISABLED",
179 * });
180 * ```
181 *
182 * ### File System Policy
183 * **Example:** Enforce in-transit encryption with a typed PolicyDocument
184 * ```typescript
185 * const files = yield* AWS.EFS.FileSystem("Files", {
186 * policy: {
187 * Version: "2012-10-17",
188 * Statement: [
189 * {
190 * Sid: "DenyUnencryptedTransport",
191 * Effect: "Deny",
192 * Principal: { AWS: "*" },
193 * Action: ["elasticfilesystem:ClientMount"],
194 * Condition: { Bool: { "aws:SecureTransport": "false" } },
195 * },
196 * ],
197 * },
198 * });
199 * ```
200 *
201 * ### Mounting into Lambda
202 * Lambda mounts EFS through an access point; the function must be attached
203 * to a VPC that can reach a mount target.
204 *
205 * **Example:** File system + mount target + access point + Lambda
206 * ```typescript
207 * const files = yield* AWS.EFS.FileSystem("Files");
208 * const target = yield* AWS.EFS.MountTarget("FilesTarget", {
209 * fileSystemId: files.fileSystemId,
210 * subnetId,
211 * });
212 * const accessPoint = yield* AWS.EFS.AccessPoint("FilesAccess", {
213 * fileSystemId: files.fileSystemId,
214 * posixUser: { uid: 1000, gid: 1000 },
215 * rootDirectory: {
216 * path: "/lambda",
217 * creationInfo: { ownerUid: 1000, ownerGid: 1000, permissions: "750" },
218 * },
219 * });
220 * const fn = yield* AWS.Lambda.Function("Api", {
221 * main: "./src/handler.ts",
222 * vpc: { subnetIds: [subnetId], securityGroupIds: [securityGroupId] },
223 * fileSystemConfigs: [
224 * // pass the AccessPoint resource itself (or its ARN)
225 * { accessPoint, localMountPath: "/mnt/files" },
226 * ],
227 * // depend on the mount target so the function is created only after
228 * // the network endpoint is available
229 * env: { EFS_MOUNT_TARGET: target.mountTargetId },
230 * });
231 * ```
232 *
233 * **Example:** Host-agnostic mount binding (Lambda or ECS)
234 * `EFS.mount` wires the mount config + least-privilege IAM through the
235 * host's binding channel — the same code works inside a Lambda Function or
236 * an ECS Task body (provide `AWS.EFS.MountLive` on the host Effect).
237 * ```typescript
238 * export default class Api extends AWS.Lambda.Function<Api>()(
239 * "Api",
240 * { main: import.meta.url, vpc: { subnetIds, securityGroupIds } },
241 * Effect.gen(function* () {
242 * const files = yield* AWS.EFS.mount(accessPoint, { path: "/mnt/files" });
243 * return Effect.fn(function* (event: unknown) {
244 * // read/write under files.path at runtime
245 * return { mountedAt: files.path };
246 * });
247 * }).pipe(Effect.provide(AWS.EFS.MountLive)),
248 * ) {}
249 * ```
250 *
251 * @resource
252 */
253 export const FileSystem = Resource<FileSystem>("AWS.EFS.FileSystem");
254
255 const isMutableEfsTagKey = (key: string): boolean => !key.toLowerCase().startsWith("aws:");
256
257 const mutableEfsTags = (tags: Record<string, string>): Record<string, string> =>
258 Object.fromEntries(Object.entries(tags).filter(([key]) => isMutableEfsTagKey(key)));
259
260 const efsTagsToRecord = (tags: readonly efs.Tag[] | undefined): Record<string, string> =>
261 Object.fromEntries(
262 (tags ?? []).filter((tag) => isMutableEfsTagKey(tag.Key)).map((tag) => [tag.Key, tag.Value]),
263 );
264
265 /**
266 * A file system briefly reports `creating`/`updating` before settling in
267 * `available`. Bounded poll (~60s), explicitly typed so declaration emit
268 * never widens the provider layer (see PATTERNS §7).
269 */
270 const retryUntilFileSystemAvailable = <E extends { _tag: string }, R>(
271 self: Effect.Effect<efs.FileSystemDescription, E, R>,
272 ): Effect.Effect<efs.FileSystemDescription, E | FileSystemNotAvailable, R> =>
273 Effect.retry(
274 Effect.flatMap(self, (fs) =>
275 fs.LifeCycleState === "available"
276 ? Effect.succeed(fs)
277 : Effect.fail(
278 new FileSystemNotAvailable({
279 fileSystemId: fs.FileSystemId,
280 state: fs.LifeCycleState,
281 }),
282 ),
283 ),
284 {
285 while: (e) => e._tag === "FileSystemNotAvailable",
286 schedule: Schedule.max([Schedule.fixed("2 seconds"), Schedule.recurs(30)]),
287 },
288 );
289
290 /**
291 * Deleting a file system whose mount targets are still tearing down (their
292 * ENIs release asynchronously) transiently fails with `FileSystemInUse`.
293 * Bounded retry (~60s), explicitly typed (PATTERNS §7).
294 */
295 const retryWhileFileSystemInUse = <A, E extends { _tag: string }, R>(
296 self: Effect.Effect<A, E, R>,
297 ): Effect.Effect<A, E, R> =>
298 Effect.retry(self, {
299 while: (e) => e._tag === "FileSystemInUse",
300 schedule: Schedule.max([Schedule.fixed("3 seconds"), Schedule.recurs(20)]),
301 });
302
303 /**
304 * Throughput updates are rejected with `IncorrectFileSystemLifeCycleState`
305 * while a previous modification is still applying. Bounded retry (~60s),
306 * explicitly typed (PATTERNS §7).
307 */
308 const retryWhileFileSystemUpdating = <A, E extends { _tag: string }, R>(
309 self: Effect.Effect<A, E, R>,
310 ): Effect.Effect<A, E, R> =>
311 Effect.retry(self, {
312 while: (e) => e._tag === "IncorrectFileSystemLifeCycleState",
313 schedule: Schedule.max([Schedule.fixed("3 seconds"), Schedule.recurs(20)]),
314 });
315
316 /**
317 * Internal marker error used to drive the bounded wait for a file system to
318 * reach the `available` lifecycle state.
319 */
320 export class FileSystemNotAvailable extends Data.TaggedError("FileSystemNotAvailable")<{
321 fileSystemId: string;
322 state: string;
323 }> {}
324
325 const toWireLifecyclePolicies = (
326 policies: FileSystemLifecyclePolicy[] | undefined,
327 ): efs.LifecyclePolicy[] =>
328 (policies ?? []).map((p) => ({
329 ...(p.transitionToIA !== undefined ? { TransitionToIA: p.transitionToIA } : {}),
330 ...(p.transitionToPrimaryStorageClass !== undefined
331 ? { TransitionToPrimaryStorageClass: p.transitionToPrimaryStorageClass }
332 : {}),
333 ...(p.transitionToArchive !== undefined ? { TransitionToArchive: p.transitionToArchive } : {}),
334 }));
335
336 const canonicalPolicies = (policies: readonly efs.LifecyclePolicy[]): string =>
337 JSON.stringify(
338 policies
339 .map((p) => ({
340 TransitionToIA: p.TransitionToIA ?? null,
341 TransitionToPrimaryStorageClass: p.TransitionToPrimaryStorageClass ?? null,
342 TransitionToArchive: p.TransitionToArchive ?? null,
343 }))
344 .sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b))),
345 );
346
347 export const FileSystemProvider = () =>
348 Provider.effect(
349 FileSystem,
350 Effect.gen(function* () {
351 const createToken = Effect.fn(function* (id: string) {
352 return yield* createPhysicalName({ id, maxLength: 64 });
353 });
354
355 const fileSystemArnOf = Effect.fn(function* (fileSystemId: string) {
356 const { accountId, region } = yield* AWSEnvironment.current;
357 return `arn:aws:elasticfilesystem:${region}:${accountId}:file-system/${fileSystemId}`;
358 });
359
360 const findByToken = Effect.fn(function* (token: string) {
361 return yield* efs.describeFileSystems({ CreationToken: token }).pipe(
362 Effect.map((r) => r.FileSystems?.[0]),
363 Effect.catchTag("FileSystemNotFound", () => Effect.undefined),
364 );
365 });
366
367 const findById = Effect.fn(function* (fileSystemId: string) {
368 return yield* efs.describeFileSystems({ FileSystemId: fileSystemId }).pipe(
369 Effect.map((r) => r.FileSystems?.[0]),
370 Effect.catchTag("FileSystemNotFound", () => Effect.undefined),
371 );
372 });
373
374 return FileSystem.Provider.of({
375 stables: ["fileSystemId", "fileSystemArn"],
376
377 list: () =>
378 Effect.gen(function* () {
379 const systems = yield* efs.describeFileSystems.items({}).pipe(
380 Stream.runCollect,
381 Effect.map((chunk) => Array.from(chunk)),
382 );
383 return yield* Effect.forEach(systems, (fs) =>
384 Effect.gen(function* () {
385 return {
386 fileSystemId: fs.FileSystemId,
387 fileSystemArn: fs.FileSystemArn ?? (yield* fileSystemArnOf(fs.FileSystemId)),
388 };
389 }),
390 );
391 }),
392
393 read: Effect.fn(function* ({ id, output }) {
394 const fs = output?.fileSystemId
395 ? yield* findById(output.fileSystemId)
396 : yield* findByToken(yield* createToken(id));
397 if (fs === undefined || fs.LifeCycleState === "deleted") {
398 return undefined;
399 }
400 const attrs = {
401 fileSystemId: fs.FileSystemId,
402 fileSystemArn: fs.FileSystemArn ?? (yield* fileSystemArnOf(fs.FileSystemId)),
403 };
404 return (yield* hasAlchemyTags(id, efsTagsToRecord(fs.Tags))) ? attrs : Unowned(attrs);
405 }),
406
407 diff: Effect.fn(function* ({ news = {}, olds = {} }) {
408 if (!isResolved(news)) return undefined;
409 const replaced =
410 (news.performanceMode ?? "generalPurpose") !==
411 (olds.performanceMode ?? "generalPurpose") ||
412 (news.encrypted ?? true) !== (olds.encrypted ?? true) ||
413 news.kmsKeyId !== olds.kmsKeyId ||
414 news.availabilityZoneName !== olds.availabilityZoneName;
415 if (replaced) {
416 return { action: "replace" } as const;
417 }
418 // undefined → default update path (throughput/lifecycle/tags sync)
419 }),
420
421 reconcile: Effect.fn(function* ({ id, news = {}, output, session }) {
422 const token = yield* createToken(id);
423 const internalTags = yield* createInternalTags(id);
424
425 // 1. OBSERVE — the creation token is the deterministic identity;
426 // output.fileSystemId is only a cache and may be stale.
427 let fs = output?.fileSystemId
428 ? yield* findById(output.fileSystemId)
429 : yield* findByToken(token);
430 if (fs?.LifeCycleState === "deleted") {
431 fs = undefined;
432 }
433
434 // 2. ENSURE — create if missing. CreateFileSystem is idempotent on
435 // the creation token; a concurrent create surfaces the typed
436 // FileSystemAlreadyExists which we resolve by re-observing.
437 if (fs === undefined) {
438 fs = yield* efs
439 .createFileSystem({
440 CreationToken: token,
441 PerformanceMode: news.performanceMode,
442 Encrypted: news.encrypted ?? true,
443 KmsKeyId: news.kmsKeyId,
444 Backup: news.backup,
445 ThroughputMode: news.throughputMode,
446 ProvisionedThroughputInMibps: news.provisionedThroughputInMibps,
447 AvailabilityZoneName: news.availabilityZoneName,
448 Tags: Object.entries(mutableEfsTags({ ...news.tags, ...internalTags })).map(
449 ([Key, Value]) => ({ Key, Value }),
450 ),
451 })
452 .pipe(
453 Effect.catchTag("FileSystemAlreadyExists", (e) =>
454 efs
455 .describeFileSystems({ FileSystemId: e.FileSystemId })
456 .pipe(Effect.map((r) => r.FileSystems![0])),
457 ),
458 );
459 }
460
461 const fileSystemId = fs.FileSystemId;
462
463 // File-system mutations (throughput, lifecycle) require the
464 // `available` state; creation settles in seconds.
465 fs = yield* retryUntilFileSystemAvailable(
466 efs
467 .describeFileSystems({ FileSystemId: fileSystemId })
468 .pipe(Effect.map((r) => r.FileSystems![0])),
469 );
470
471 // 3a. SYNC throughput — observed vs desired; only call the API on a
472 // real delta.
473 if (news.throughputMode !== undefined) {
474 const modeChanged = fs.ThroughputMode !== news.throughputMode;
475 const provisionedChanged =
476 news.throughputMode === "provisioned" &&
477 fs.ProvisionedThroughputInMibps !== news.provisionedThroughputInMibps;
478 if (modeChanged || provisionedChanged) {
479 yield* retryWhileFileSystemUpdating(
480 efs.updateFileSystem({
481 FileSystemId: fileSystemId,
482 ThroughputMode: news.throughputMode,
483 ProvisionedThroughputInMibps:
484 news.throughputMode === "provisioned"
485 ? news.provisionedThroughputInMibps
486 : undefined,
487 }),
488 );
489 }
490 }
491
492 // 3b. SYNC lifecycle policies — a PUT with the full desired list;
493 // an empty list clears lifecycle management.
494 const observedPolicies = yield* efs
495 .describeLifecycleConfiguration({ FileSystemId: fileSystemId })
496 .pipe(Effect.map((r) => r.LifecyclePolicies ?? []));
497 const desiredPolicies = toWireLifecyclePolicies(news.lifecyclePolicies);
498 if (canonicalPolicies(observedPolicies) !== canonicalPolicies(desiredPolicies)) {
499 yield* retryWhileFileSystemUpdating(
500 efs.putLifecycleConfiguration({
501 FileSystemId: fileSystemId,
502 LifecyclePolicies: desiredPolicies,
503 }),
504 );
505 }
506
507 // 3c. SYNC backup policy — observed vs desired; only call the API
508 // on a real delta. An in-flight transition (ENABLING/
509 // DISABLING) counts as its target state. When the prop is
510 // omitted the AWS default is left alone.
511 if (news.backup !== undefined) {
512 const observedBackupStatus = yield* efs
513 .describeBackupPolicy({ FileSystemId: fileSystemId })
514 .pipe(
515 Effect.map((r) => r.BackupPolicy?.Status),
516 Effect.catchTag("PolicyNotFound", () => Effect.undefined),
517 );
518 const observedBackup =
519 observedBackupStatus === "ENABLED" || observedBackupStatus === "ENABLING";
520 if (observedBackup !== news.backup) {
521 yield* retryWhileFileSystemUpdating(
522 efs.putBackupPolicy({
523 FileSystemId: fileSystemId,
524 BackupPolicy: {
525 Status: news.backup ? "ENABLED" : "DISABLED",
526 },
527 }),
528 );
529 }
530 }
531
532 // 3d. SYNC replication overwrite protection — observed vs desired
533 // from the file system description. When the prop is omitted
534 // the current protection setting is left alone.
535 if (news.replicationOverwriteProtection !== undefined) {
536 const observedProtection =
537 fs.FileSystemProtection?.ReplicationOverwriteProtection ?? "ENABLED";
538 if (observedProtection !== news.replicationOverwriteProtection) {
539 yield* retryWhileFileSystemUpdating(
540 efs.updateFileSystemProtection({
541 FileSystemId: fileSystemId,
542 ReplicationOverwriteProtection: news.replicationOverwriteProtection,
543 }),
544 );
545 }
546 }
547
548 // 3e. SYNC file system policy — compare the observed policy with
549 // the desired one after canonicalization (sorted keys, no
550 // whitespace) so a re-deploy of an equivalent document is a
551 // no-op API-wise.
552 const observedPolicy = yield* efs
553 .describeFileSystemPolicy({ FileSystemId: fileSystemId })
554 .pipe(
555 Effect.map((r) => r.Policy),
556 Effect.catchTag("PolicyNotFound", () => Effect.undefined),
557 );
558 const desiredPolicy =
559 news.policy === undefined
560 ? undefined
561 : typeof news.policy === "string"
562 ? news.policy
563 : stringifyPolicyDocument(news.policy);
564 if (desiredPolicy === undefined) {
565 if (observedPolicy !== undefined) {
566 yield* retryWhileFileSystemUpdating(
567 efs.deleteFileSystemPolicy({ FileSystemId: fileSystemId }),
568 );
569 }
570 } else if (
571 observedPolicy === undefined ||
572 normalizePolicyDocument(observedPolicy) !== normalizePolicyDocument(desiredPolicy)
573 ) {
574 yield* retryWhileFileSystemUpdating(
575 efs.putFileSystemPolicy({
576 FileSystemId: fileSystemId,
577 Policy: desiredPolicy,
578 }),
579 );
580 }
581
582 // 3f. SYNC tags — diff against OBSERVED cloud tags so adoption
583 // converges.
584 const observedTags = efsTagsToRecord(fs.Tags);
585 const desiredTags = mutableEfsTags({
586 ...news.tags,
587 ...internalTags,
588 });
589 const { upsert, removed } = diffTags(observedTags, desiredTags);
590 if (upsert.length > 0) {
591 yield* efs.tagResource({
592 ResourceId: fileSystemId,
593 Tags: upsert,
594 });
595 }
596 if (removed.length > 0) {
597 yield* efs.untagResource({
598 ResourceId: fileSystemId,
599 TagKeys: removed,
600 });
601 }
602
603 yield* session.note(fileSystemId);
604 return {
605 fileSystemId,
606 fileSystemArn: fs.FileSystemArn ?? (yield* fileSystemArnOf(fileSystemId)),
607 };
608 }),
609
610 delete: Effect.fn(function* ({ output }) {
611 yield* retryWhileFileSystemInUse(
612 efs.deleteFileSystem({ FileSystemId: output.fileSystemId }),
613 ).pipe(Effect.catchTag("FileSystemNotFound", () => Effect.void));
614 }),
615 });
616 }),
617 );