@danieljvdm/dev-kit 0.5.0 → 0.7.0

package/skills/effect-ts/references/guide-schedule.md

@@ -49,9 +49,9 @@ attempt limits, and backoff in the schedule.
 Use the operator that matches the control flow:
 
 ```ts
-const retried = Effect.retry(loadRemote, retryPolicy)
-const repeated = Effect.repeat(refreshCache, refreshPolicy)
-const scheduled = Effect.schedule(runJob, nightly)
+const retried = Effect.retry(loadRemote, retryPolicy);
+const repeated = Effect.repeat(refreshCache, refreshPolicy);
+const scheduled = Effect.schedule(runJob, nightly);
 ```
 
 - `retry` steps the schedule when the effect fails; the schedule input is the
@@ -69,7 +69,7 @@ before the schedule is stepped, so `recurs(3)` permits one initial attempt and
 up to three retries.
 
 ```ts
-const retryThreeTimes = Schedule.recurs(3)
+const retryThreeTimes = Schedule.recurs(3);
 ```
 
 ### `Schedule.forever`
@@ -78,7 +78,7 @@ const retryThreeTimes = Schedule.recurs(3)
 combinators unless a tight loop is intentional.
 
 ```ts
-const unbounded = Schedule.forever
+const unbounded = Schedule.forever;
 ```
 
 ### `Schedule.spaced`
@@ -86,7 +86,7 @@ const unbounded = Schedule.forever
 Use `spaced` when each delay starts after the preceding action completes.
 
 ```ts
-const pollEverySecond = Schedule.spaced("1 second")
+const pollEverySecond = Schedule.spaced("1 second");
 ```
 
 ### `Schedule.fixed`
@@ -95,7 +95,7 @@ Use `fixed` for a regular cadence that accounts for the time spent running the
 action. This differs from naïve spacing when the action itself is slow.
 
 ```ts
-const everyMinute = Schedule.fixed("1 minute")
+const everyMinute = Schedule.fixed("1 minute");
 ```
 
 ### `Schedule.windowed`
@@ -103,7 +103,7 @@ const everyMinute = Schedule.fixed("1 minute")
 Use `windowed` to align work to the nearest interval boundary.
 
 ```ts
-const flushOnTenSecondWindows = Schedule.windowed("10 seconds")
+const flushOnTenSecondWindows = Schedule.windowed("10 seconds");
 ```
 
 ### `Schedule.duration`
@@ -111,7 +111,7 @@ const flushOnTenSecondWindows = Schedule.windowed("10 seconds")
 `duration` recurs once after the given delay, then completes.
 
 ```ts
-const onceAfterOneSecond = Schedule.duration("1 second")
+const onceAfterOneSecond = Schedule.duration("1 second");
 ```
 
 ### `Schedule.during`
@@ -119,7 +119,7 @@ const onceAfterOneSecond = Schedule.duration("1 second")
 `during` recurs only within an elapsed-time window.
 
 ```ts
-const forThirtySeconds = Schedule.during("30 seconds")
+const forThirtySeconds = Schedule.during("30 seconds");
 ```
 
 ### `Schedule.cron`
@@ -129,7 +129,7 @@ with `CronParseError`, so keep that failure visible where the expression is not
 a trusted constant.
 
 ```ts
-const nightly = Schedule.cron("0 0 * * *")
+const nightly = Schedule.cron("0 0 * * *");
 ```
 
 ## Backoff
@@ -139,7 +139,7 @@ const nightly = Schedule.cron("0 0 * * *")
 Use exponential backoff for transient external failures.
 
 ```ts
-const backoff = Schedule.exponential("100 millis", 2)
+const backoff = Schedule.exponential("100 millis", 2);
 ```
 
 Bound the policy explicitly:
@@ -148,7 +148,7 @@ Bound the policy explicitly:
 const boundedBackoff = Schedule.exponential("100 millis").pipe(
   Schedule.upTo({ duration: "30 seconds", times: 6 }),
   Schedule.jittered,
-)
+);
 ```
 
 ### `Schedule.fibonacci`
@@ -156,9 +156,7 @@ const boundedBackoff = Schedule.exponential("100 millis").pipe(
 Use Fibonacci backoff when growth should be gentler than exponential.
 
 ```ts
-const fibonacciBackoff = Schedule.fibonacci("100 millis").pipe(
-  Schedule.upTo({ times: 6 }),
-)
+const fibonacciBackoff = Schedule.fibonacci("100 millis").pipe(Schedule.upTo({ times: 6 }));
 ```
 
 ### `Schedule.jittered`
@@ -167,9 +165,7 @@ Use jitter for distributed clients, workers, or polling loops that might
 otherwise synchronize their retries.
 
 ```ts
-const jittered = Schedule.exponential("200 millis").pipe(
-  Schedule.jittered,
-)
+const jittered = Schedule.exponential("200 millis").pipe(Schedule.jittered);
 ```
 
 ## Bounding Policies
@@ -184,7 +180,7 @@ const bounded = Schedule.spaced("1 second").pipe(
     duration: "20 seconds",
     times: 5,
   }),
-)
+);
 ```
 
 Prefer `upTo` over rebuilding count and elapsed-time checks with mutable state.
@@ -198,10 +194,8 @@ Use `andThen` when one policy should complete before another begins.
 ```ts
 const quickThenSlow = Schedule.exponential("100 millis").pipe(
   Schedule.upTo({ times: 3 }),
-  Schedule.andThen(
-    Schedule.spaced("5 seconds").pipe(Schedule.upTo({ times: 5 })),
-  ),
-)
+  Schedule.andThen(Schedule.spaced("5 seconds").pipe(Schedule.upTo({ times: 5 }))),
+);
 ```
 
 This is the v4 replacement for older examples that used `Schedule.either` to
@@ -221,10 +215,7 @@ largest delay. Use it to enforce several stop conditions while retaining the
 slowest applicable cadence.
 
 ```ts
-const countedBackoff = Schedule.max([
-  Schedule.exponential("100 millis"),
-  Schedule.recurs(5),
-])
+const countedBackoff = Schedule.max([Schedule.exponential("100 millis"), Schedule.recurs(5)]);
 ```
 
 ### `Schedule.min`
@@ -234,10 +225,7 @@ smallest available delay. Use it only when that "any policy may continue"
 behavior is intended.
 
 ```ts
-const fastestAvailable = Schedule.min([
-  Schedule.spaced("1 second"),
-  Schedule.spaced("5 seconds"),
-])
+const fastestAvailable = Schedule.min([Schedule.spaced("1 second"), Schedule.spaced("5 seconds")]);
 ```
 
 Do not treat `max` and `min` as ordinary numeric delay combinators without
@@ -252,9 +240,9 @@ Use `modifyDelay` to replace the computed delay from schedule metadata.
 ```ts
 const cappedDelay = Schedule.exponential("100 millis").pipe(
   Schedule.modifyDelay(({ duration }) =>
-    Effect.succeed(Duration.min(duration, Duration.seconds(5)))
+    Effect.succeed(Duration.min(duration, Duration.seconds(5))),
   ),
-)
+);
 ```
 
 ### `Schedule.addDelay`
@@ -266,11 +254,9 @@ For retries, inspect the typed error through `metadata.input`.
 const serverAware = Schedule.spaced("1 second").pipe(
   Schedule.setInputType<RateLimitedError>(),
   Schedule.addDelay(({ input: error }) =>
-    error._tag === "RateLimited"
-      ? Effect.succeed(error.retryAfter)
-      : Effect.succeed(Duration.zero)
+    error._tag === "RateLimited" ? Effect.succeed(error.retryAfter) : Effect.succeed(Duration.zero),
   ),
-)
+);
 ```
 
 ### `Schedule.map`
@@ -299,9 +285,9 @@ const observed = Schedule.exponential("100 millis").pipe(
         delay: String(duration),
         errorTag: input._tag,
       }),
-    )
+    ),
   ),
-)
+);
 ```
 
 ## Advanced Construction And Inspection

package/skills/effect-ts/references/guide-schema.md

@@ -57,16 +57,14 @@ Make Schema the source of truth for application data. Export the schema value
 and derive its decoded TypeScript type from `.Type` under the same name.
 
 ```ts
-export const ArtifactId = Schema.NonEmptyString.pipe(
-  Schema.brand("@acme/ArtifactId")
-)
-export type ArtifactId = typeof ArtifactId.Type
+export const ArtifactId = Schema.NonEmptyString.pipe(Schema.brand("@acme/ArtifactId"));
+export type ArtifactId = typeof ArtifactId.Type;
 
 export const GenerateInput = Schema.Struct({
   artifactId: ArtifactId,
-  prompt: Schema.String
-})
-export type GenerateInput = typeof GenerateInput.Type
+  prompt: Schema.String,
+});
+export type GenerateInput = typeof GenerateInput.Type;
 ```
 
 Use schema classes for named reusable models when their validated construction,
@@ -127,14 +125,14 @@ Bad pattern:
 const Todo = Schema.Struct({
   id: Schema.Number,
   title: Schema.String,
-  completed: Schema.Boolean
-})
+  completed: Schema.Boolean,
+});
 
 const TodoSql = Schema.Struct({
   id: Schema.Number,
   title: Schema.String,
-  completed: Schema.BooleanFromBit
-})
+  completed: Schema.BooleanFromBit,
+});
 ```
 
 This is usually a sign that transformations are not being used properly.
@@ -165,23 +163,23 @@ When a schema represents a named domain model, reusable payload, or long-lived A
 Prefer:
 
 ```ts
-import { Schema } from "effect"
+import { Schema } from "effect";
 
 export class User extends Schema.Class<User>("User")({
   id: Schema.String,
-  name: Schema.String
+  name: Schema.String,
 }) {}
 ```
 
 Over:
 
 ```ts
-import { Schema } from "effect"
+import { Schema } from "effect";
 
 export const User = Schema.Struct({
   id: Schema.String,
-  name: Schema.String
-})
+  name: Schema.String,
+});
 ```
 
 Why `Class` variants are usually better:
@@ -248,8 +246,8 @@ Example:
 const Todo = Schema.Struct({
   id: Schema.Number,
   title: Schema.String,
-  completed: Schema.Boolean
-})
+  completed: Schema.Boolean,
+});
 ```
 
 ## `Class`, `TaggedClass`, and `TaggedErrorClass`
@@ -261,7 +259,7 @@ Use for named reusable schema-backed models.
 ```ts
 class Product extends Schema.Class<Product>("Product")({
   id: Schema.String,
-  price: Schema.Number
+  price: Schema.Number,
 }) {}
 ```
 
@@ -275,8 +273,8 @@ Prefer:
 const todo = Todo.make({
   id: 1,
   title: "write docs",
-  completed: false
-})
+  completed: false,
+});
 ```
 
 Over:
@@ -285,8 +283,8 @@ Over:
 const todo = new Todo({
   id: 1,
   title: "write docs",
-  completed: false
-})
+  completed: false,
+});
 ```
 
 Why:
@@ -308,12 +306,12 @@ Use for members of tagged unions.
 
 ```ts
 class Circle extends Schema.TaggedClass<Circle>()("Circle", {
-  radius: Schema.Number
+  radius: Schema.Number,
 }) {}
 
 class Rectangle extends Schema.TaggedClass<Rectangle>()("Rectangle", {
   width: Schema.Number,
-  height: Schema.Number
+  height: Schema.Number,
 }) {}
 ```
 
@@ -323,7 +321,7 @@ Use for schema-backed typed errors.
 
 ```ts
 class NotFound extends Schema.TaggedErrorClass<NotFound>()("NotFound", {
-  id: Schema.String
+  id: Schema.String,
 }) {}
 ```
 
@@ -342,8 +340,8 @@ Prefer:
 
 ```ts
 const Query = Schema.Struct({
-  search: Schema.optionalKey(Schema.String)
-})
+  search: Schema.optionalKey(Schema.String),
+});
 ```
 
 Use `optional` when the value itself should be `A | undefined`, not just an omitted field.
@@ -353,24 +351,21 @@ Use `optional` when the value itself should be `A | undefined`, not just an omit
 Use `Schema.Union([...])` for ordinary unions.
 
 ```ts
-const Id = Schema.Union([
-  Schema.String,
-  Schema.Number
-])
+const Id = Schema.Union([Schema.String, Schema.Number]);
 ```
 
 Prefer tagged unions for domain variants.
 
 ```ts
 class Created extends Schema.TaggedClass<Created>()("Created", {
-  id: Schema.String
+  id: Schema.String,
 }) {}
 
 class Deleted extends Schema.TaggedClass<Deleted>()("Deleted", {
-  id: Schema.String
+  id: Schema.String,
 }) {}
 
-const TodoEvent = Schema.Union([Created, Deleted])
+const TodoEvent = Schema.Union([Created, Deleted]);
 ```
 
 Why:
@@ -384,14 +379,14 @@ Use `Schema.suspend` for recursive schemas.
 
 ```ts
 type Tree = {
-  readonly name: string
-  readonly children: ReadonlyArray<Tree>
-}
+  readonly name: string;
+  readonly children: ReadonlyArray<Tree>;
+};
 
 const Tree: Schema.Schema<Tree> = Schema.Struct({
   name: Schema.String,
-  children: Schema.Array(Schema.suspend((): Schema.Schema<Tree> => Tree))
-})
+  children: Schema.Array(Schema.suspend((): Schema.Schema<Tree> => Tree)),
+});
 ```
 
 Use it whenever a schema refers to itself, directly or indirectly.
@@ -416,9 +411,9 @@ Use `decodeTo` when you want one schema to decode into another schema's type.
 const TrimmedString = Schema.String.pipe(
   Schema.decodeTo(Schema.String, {
     decode: (value) => value.trim(),
-    encode: (value) => value
-  })
-)
+    encode: (value) => value,
+  }),
+);
 ```
 
 The canonical docs explicitly note that `decodeTo` is curried and should be used with `pipe`.
@@ -432,19 +427,19 @@ Use `encodeTo` when the reverse direction reads more clearly.
 Use `transformOrFail` when the transformation itself is effectful or may fail.
 
 ```ts
-import * as Effect from "effect/Effect"
-import * as Schema from "effect/Schema"
-import * as SchemaTransformation from "effect/SchemaTransformation"
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
 
 const VerifiedString = Schema.String.pipe(
   Schema.decodeTo(
     Schema.String,
     SchemaTransformation.transformOrFail({
       decode: (value) => Effect.succeed(value.trim()),
-      encode: (value) => Effect.succeed(value)
-    })
-  )
-)
+      encode: (value) => Effect.succeed(value),
+    }),
+  ),
+);
 ```
 
 Use this when:
@@ -460,13 +455,13 @@ Very often, the right answer is not a second object schema but a transformed fie
 Example shape:
 
 ```ts
-const Completed = Schema.BooleanFromBit
+const Completed = Schema.BooleanFromBit;
 
 const Todo = Schema.Struct({
   id: Schema.Number,
   title: Schema.String,
-  completed: Completed
-})
+  completed: Completed,
+});
 ```
 
 In this pattern:
@@ -519,9 +514,7 @@ Use opaque or branded schemas when a value should stay distinct from its structu
 Use `brand` for refined nominal distinctions.
 
 ```ts
-const UserId = Schema.String.pipe(
-  Schema.brand("UserId")
-)
+const UserId = Schema.String.pipe(Schema.brand("UserId"));
 ```
 
 This is useful for:
@@ -598,7 +591,7 @@ Preferred rule:
 Good pattern:
 
 ```ts
-const decodeUser = Schema.decodeUnknownEffect(User)
+const decodeUser = Schema.decodeUnknownEffect(User);
 ```
 
 ## Schema Metadata And Derived Tooling

package/skills/effect-ts/references/guide-sql.md

@@ -79,7 +79,7 @@ Prefer typed SQL queries instead of leaving row shapes implicit.
 The repo uses typed query literals like:
 
 ```ts
-const rows = yield* sql<{ id: number; name: string }>`SELECT * FROM test`
+const rows = yield * sql<{ id: number; name: string }>`SELECT * FROM test`;
 ```
 
 This is the first level of typed SQL usage and is already better than untyped row access.
@@ -111,8 +111,8 @@ Why:
 Avoid this pattern:
 
 ```ts
-const row = yield* sql`SELECT id, title FROM todos WHERE id = ${id}`
-const todo = row[0] as TodoRow
+const row = yield * sql`SELECT id, title FROM todos WHERE id = ${id}`;
+const todo = row[0] as TodoRow;
 ```
 
 Prefer:
@@ -126,10 +126,10 @@ Example boundary decode:
 const TodoRow = Schema.Struct({
   id: Schema.Number,
   title: Schema.String,
-  completed: Schema.Boolean
-})
+  completed: Schema.Boolean,
+});
 
-const decodeTodoRows = Schema.decodeUnknownEffect(Schema.Array(TodoRow))
+const decodeTodoRows = Schema.decodeUnknownEffect(Schema.Array(TodoRow));
 ```
 
 Then keep the query and decoding together in one SQL-aware operation.
@@ -150,11 +150,11 @@ const resolver = SqlResolver.findById({
   Id: Schema.Number,
   Result: Schema.Struct({
     id: Schema.Number,
-    name: Schema.String
+    name: Schema.String,
   }),
   ResultId: (row) => row.id,
-  execute: (ids) => sql`SELECT * FROM test WHERE id IN ${sql.in(ids)}`
-})
+  execute: (ids) => sql`SELECT * FROM test WHERE id IN ${sql.in(ids)}`,
+});
 ```
 
 This is a preferred pattern when:
@@ -201,17 +201,17 @@ Prefer a layer that provides `SqlClient`, and let domain services depend on that
 Good pattern:
 
 ```ts
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as SqlClient from "effect/unstable/sql/SqlClient"
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
 
 class TodoRepo extends Context.Service<TodoRepo>()("TodoRepo", {
   make: Effect.succeed({
-    getById: Effect.fn("TodoRepo.getById")(function*(id: number) {
-      const sql = yield* SqlClient.SqlClient
-      return yield* sql`SELECT id, title, completed FROM todos WHERE id = ${id}`
-    })
-  })
+    getById: Effect.fn("TodoRepo.getById")(function* (id: number) {
+      const sql = yield* SqlClient.SqlClient;
+      return yield* sql`SELECT id, title, completed FROM todos WHERE id = ${id}`;
+    }),
+  }),
 }) {}
 ```
 
@@ -233,16 +233,16 @@ Repo reference:
 Prefer:
 
 ```ts
-const createAndAudit = Effect.fn("TodoRepo.createAndAudit")(function*(title: string) {
-  const sql = yield* SqlClient.SqlClient
+const createAndAudit = Effect.fn("TodoRepo.createAndAudit")(function* (title: string) {
+  const sql = yield* SqlClient.SqlClient;
 
   return yield* sql.withTransaction(
-    Effect.gen(function*() {
-      yield* sql`INSERT INTO todos ${sql.insert({ title, completed: false })}`
-      yield* sql`INSERT INTO audit_log ${sql.insert({ event: "todo_created" })}`
-    })
-  )
-})
+    Effect.gen(function* () {
+      yield* sql`INSERT INTO todos ${sql.insert({ title, completed: false })}`;
+      yield* sql`INSERT INTO audit_log ${sql.insert({ event: "todo_created" })}`;
+    }),
+  );
+});
 ```
 
 Avoid:
@@ -265,10 +265,10 @@ Avoid exposing one exported accessor function per SQL service method if it only
 Bad:
 
 ```ts
-export const createTodo = Effect.fn(function*(title: string) {
-  const todos = yield* TodoRepo
-  return yield* todos.create(title)
-})
+export const createTodo = Effect.fn(function* (title: string) {
+  const todos = yield* TodoRepo;
+  return yield* todos.create(title);
+});
 ```
 
 Prefer:
@@ -352,25 +352,25 @@ The runtime-specific SQL migrator packages expose `fromRecord(...)` to define mi
 Example shape:
 
 ```ts
-import * as SqliteMigrator from "@effect/sql-sqlite-bun/SqliteMigrator"
-import * as Effect from "effect/Effect"
+import * as SqliteMigrator from "@effect/sql-sqlite-bun/SqliteMigrator";
+import * as Effect from "effect/Effect";
 
 const migrations = SqliteMigrator.fromRecord({
-  "1_create_todos": Effect.gen(function*() {
+  "1_create_todos": Effect.gen(function* () {
     yield* sql`
       CREATE TABLE todos (
         id INTEGER PRIMARY KEY NOT NULL,
         title TEXT NOT NULL,
         completed INTEGER NOT NULL DEFAULT 0
       )
-    `.withoutTransform
+    `.withoutTransform;
   }),
-  "2_add_todo_index": Effect.gen(function*() {
+  "2_add_todo_index": Effect.gen(function* () {
     yield* sql`
       CREATE INDEX todos_completed_idx ON todos (completed)
-    `.withoutTransform
-  })
-})
+    `.withoutTransform;
+  }),
+});
 ```
 
 This matches the model used by the canonical migrator implementation:
@@ -386,11 +386,11 @@ Use the runtime-specific `run(...)` helper when you want a startup effect that r
 Example shape:
 
 ```ts
-import * as SqliteMigrator from "@effect/sql-sqlite-bun/SqliteMigrator"
+import * as SqliteMigrator from "@effect/sql-sqlite-bun/SqliteMigrator";
 
 const runMigrations = SqliteMigrator.run({
-  loader: migrations
-})
+  loader: migrations,
+});
 ```
 
 This is a good fit when:
@@ -408,11 +408,11 @@ Use the runtime-specific `layer(...)` helper when migrations should run as part
 Example shape:
 
 ```ts
-import * as SqliteMigrator from "@effect/sql-sqlite-bun/SqliteMigrator"
+import * as SqliteMigrator from "@effect/sql-sqlite-bun/SqliteMigrator";
 
 const MigrationLayer = SqliteMigrator.layer({
-  loader: migrations
-})
+  loader: migrations,
+});
 ```
 
 From the canonical packages, this is implemented as `Layer.effectDiscard(run(options))`.
@@ -428,16 +428,13 @@ That means:
 Preferred shape:
 
 ```ts
-const SqlLayer = SqliteClient.layer({ filename: "todos.sqlite" })
+const SqlLayer = SqliteClient.layer({ filename: "todos.sqlite" });
 
 const MigrationLayer = SqliteMigrator.layer({
-  loader: migrations
-})
+  loader: migrations,
+});
 
-const MigratedSqlLayer = Layer.merge(
-  SqlLayer,
-  MigrationLayer.pipe(Layer.provide(SqlLayer))
-)
+const MigratedSqlLayer = Layer.merge(SqlLayer, MigrationLayer.pipe(Layer.provide(SqlLayer)));
 ```
 
 This keeps the structure explicit: