effect-app 4.0.0-beta.253 → 4.0.0-beta.255

package/dist/ids.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../src/ids.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,KAAK,EAAE,iBAAiB,EAAY,KAAK,aAAa,EAAmB,MAAM,mBAAmB,CAAA;AACjI,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,0BAA0B,CAAA;AAEjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,CAAC,MAAM,aAAa,CAAA;AAGhC,MAAM,WAAW,cAAe,SAAQ,aAAa;IACnD,QAAQ,CAAC,SAAS,EAAE,OAAO,MAAM,CAAA;CAClC;AAED,MAAM,MAAM,SAAS,GAAG,iBAAiB,CAAA;AACzC;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS;gBAIkB,iBAAiB;IAGnD;;;;;OAKG;;;;IALH;;;;;OAKG;;CAKe,CAAA;AAExB,MAAM,WAAW,kBAAmB,SAAQ,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,GAAG,aAAa,CAAC;CAAG;AACjG,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,kBAAkB,CAAA;AACvD;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;;;8DAAmC,CAAA"}
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../src/ids.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,KAAK,EAAE,iBAAiB,EAAY,KAAK,aAAa,EAAmB,MAAM,mBAAmB,CAAA;AACjI,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,0BAA0B,CAAA;AAEjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,CAAC,MAAM,aAAa,CAAA;AAGhC,MAAM,WAAW,cAAe,SAAQ,aAAa;IACnD,QAAQ,CAAC,SAAS,EAAE,OAAO,MAAM,CAAA;CAClC;AAED,MAAM,MAAM,SAAS,GAAG,iBAAiB,CAAA;AACzC;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS;gBAIkB,iBAAiB;IAGnD;;;;;OAKG;;;;IALH;;;;;OAKG;;CAKe,CAAA;AAExB,MAAM,WAAW,kBAAmB,SAAQ,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,GAAG,aAAa,CAAC;CAAG;AACjG,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,kBAAkB,CAAA;AACvD;;;;;GAKG;AACH,eAAO,MAAM,aAAa,wCAAmC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-app",
-  "version": "4.0.0-beta.253",
+  "version": "4.0.0-beta.255",
   "license": "MIT",
   "type": "module",
   "dependencies": {
@@ -24,7 +24,7 @@
     "vitest": "^4.1.5"
   },
   "peerDependencies": {
-    "effect": "^4.0.0-beta.70"
+    "effect": "^4.0.0-beta.71"
   },
   "typesVersions": {
     "*": {

package/src/Model/Repository/internal/internal.ts

@@ -2,6 +2,7 @@
 
 import * as Equivalence from "effect/Equivalence"
 import { flow, pipe } from "effect/Function"
+import * as HashMap from "effect/HashMap"
 import * as HashSet from "effect/HashSet"
 import * as Pipeable from "effect/Pipeable"
 import * as Ref from "effect/Ref"
@@ -21,10 +22,10 @@ import * as Option from "../../../Option.js"
 import * as S from "../../../Schema.js"
 import { type Codec, NonNegativeInt } from "../../../Schema.js"
 import { setupRequestContextFromCurrent } from "../../../setupRequest.ts"
-import { type FilterArgs, getContextMap, type PersistenceModelType, type StoreConfig, StoreMaker } from "../../../Store.js"
+import { type FilterArgs, getContextMap, type PersistenceModelType, type StoreConfig, storeId, StoreMaker } from "../../../Store.js"
 import type { FieldValues } from "../../filter/types.js"
 import * as Q from "../../query.js"
-import type { ChangeFeed, Repository } from "../service.js"
+import type { ChangeFeed, ChangeFeedEvent, Repository } from "../service.js"
 import { ValidationError, ValidationResult } from "../validation.js"
 
 const dedupe = Array.dedupeWith(Equivalence.String)
@@ -108,22 +109,48 @@ export function makeRepoInternal<
             ? args.publishEvents
             : () => Effect.void
 
-          type ChangeFeedEvt = [T[], "save" | "remove"]
-          type ChangeFeedHandler = (evt: ChangeFeedEvt) => Effect.Effect<void>
-          const changeFeedHandlers = yield* Ref.make(HashSet.empty<ChangeFeedHandler>())
+          type ChangeFeedHandler = (evt: ChangeFeedEvent<T>) => Effect.Effect<void>
+          const changeFeedByNamespace = yield* Ref.make(HashMap.empty<string, HashSet.HashSet<ChangeFeedHandler>>())
+          const changeFeedWildcard = yield* Ref.make(HashSet.empty<ChangeFeedHandler>())
           // clear all handlers when the repository's scope closes
-          yield* Effect.addFinalizer(() => Ref.set(changeFeedHandlers, HashSet.empty<ChangeFeedHandler>()))
+          yield* Effect.addFinalizer(() =>
+            Effect.all([
+              Ref.set(changeFeedByNamespace, HashMap.empty<string, HashSet.HashSet<ChangeFeedHandler>>()),
+              Ref.set(changeFeedWildcard, HashSet.empty<ChangeFeedHandler>())
+            ], { discard: true })
+          )
           const changeFeed: ChangeFeed<T> = {
-            publish: (evt) =>
-              Effect.flatMap(
-                Ref.get(changeFeedHandlers),
-                (hs) => Effect.forEach(hs, (h) => h(evt), { concurrency: "unbounded", discard: true })
-              ),
-            subscribe: (handler) =>
-              Effect.acquireRelease(
-                Ref.update(changeFeedHandlers, HashSet.add(handler)),
-                () => Ref.update(changeFeedHandlers, HashSet.remove(handler))
+            publish: ([items, op]) =>
+              Effect.gen(function*() {
+                const ns = yield* storeId
+                const evt: ChangeFeedEvent<T> = [items, op, ns]
+                const map = yield* Ref.get(changeFeedByNamespace)
+                const wild = yield* Ref.get(changeFeedWildcard)
+                const targeted = Option.getOrElse(HashMap.get(map, ns), () => HashSet.empty<ChangeFeedHandler>())
+                const all = HashSet.union(targeted, wild)
+                yield* Effect.forEach(all, (h) => h(evt), { concurrency: "unbounded", discard: true })
+              }),
+            subscribe: (handler, options) => {
+              const ns = options?.namespace
+              if (ns === undefined) {
+                return Effect.acquireRelease(
+                  Ref.update(changeFeedWildcard, HashSet.add(handler)),
+                  () => Ref.update(changeFeedWildcard, HashSet.remove(handler))
+                )
+              }
+              return Effect.acquireRelease(
+                Ref.update(changeFeedByNamespace, (m) => {
+                  const cur = Option.getOrElse(HashMap.get(m, ns), () => HashSet.empty<ChangeFeedHandler>())
+                  return HashMap.set(m, ns, HashSet.add(cur, handler))
+                }),
+                () =>
+                  Ref.update(changeFeedByNamespace, (m) => {
+                    const cur = Option.getOrElse(HashMap.get(m, ns), () => HashSet.empty<ChangeFeedHandler>())
+                    const next = HashSet.remove(cur, handler)
+                    return HashSet.size(next) === 0 ? HashMap.remove(m, ns) : HashMap.set(m, ns, next)
+                  })
               )
+            }
           }
 
           const allE = cms

package/src/Model/Repository/service.ts

@@ -10,19 +10,30 @@ import type { QAll, Query, QueryProjection, RawQuery } from "../query.js"
 import type { Mapped } from "./legacy.js"
 import type { ValidationResult } from "./validation.js"
 
+/**
+ * Event emitted by a repository's ChangeFeed.
+ *
+ * Tuple shape: `[items, op, namespace]` — `namespace` is the `storeId`
+ * context value at publish time (defaults to `"primary"`).
+ */
+export type ChangeFeedEvent<T> = readonly [items: T[], op: "save" | "remove", namespace: string]
+
 /**
  * Synchronous broadcast channel for repository change events.
  *
- * `publish` only completes after every currently-subscribed handler's Effect
- * has finished — callers must await all handlers before continuing. Handlers
- * registered via `subscribe` are auto-removed when the subscriber's Scope
- * closes, and the full handler set is cleared when the repository's own scope
- * closes.
+ * `publish` only completes after every matching handler's Effect has
+ * finished — callers must await all handlers before continuing. Subscribers
+ * can target a single namespace via `options.namespace`, or omit it to
+ * receive events from every namespace (wildcard).
+ *
+ * Handlers are auto-removed when the subscriber's Scope closes; the full
+ * handler set is cleared when the repository's own scope closes.
  */
 export interface ChangeFeed<T> {
   readonly publish: (evt: [T[], "save" | "remove"]) => Effect.Effect<void>
   readonly subscribe: (
-    handler: (evt: [T[], "save" | "remove"]) => Effect.Effect<void>
+    handler: (evt: ChangeFeedEvent<T>) => Effect.Effect<void>,
+    options?: { readonly namespace?: string }
   ) => Effect.Effect<void, never, Scope.Scope>
 }
 

package/src/Schema/moreStrings.ts

@@ -21,6 +21,9 @@ import { withDefaultMake, type WithDefaults } from "./ext.js"
 import { type B } from "./schema.js"
 import type { NonEmptyString255Brand, NonEmptyStringBrand } from "./strings.js"
 
+type BrandedStringSchema<A extends string> = S.Codec<A, string> & WithDefaults<S.Codec<A, string>>
+type ConstructorDefaultBaseSchema<A> = S.Codec<A, string> & S.WithoutConstructorDefault
+type WithConstructorDefaultSchema<A> = S.withConstructorDefault<ConstructorDefaultBaseSchema<A>>
 const nonEmptyString = S.NonEmptyString
 
 /**
@@ -36,7 +39,8 @@ export type NonEmptyString50 = string & NonEmptyString50Brand
 /**
  * A string that is at least 1 character long and a maximum of 50.
  */
-export const NonEmptyString50 = nonEmptyString.pipe(
+export interface NonEmptyString50Schema extends BrandedStringSchema<NonEmptyString50> {}
+export const NonEmptyString50: NonEmptyString50Schema = nonEmptyString.pipe(
   S.check(S.isMaxLength(50)),
   fromBrand<NonEmptyString50>(nominal<NonEmptyString50>(), {
     identifier: "NonEmptyString50",
@@ -58,7 +62,8 @@ export type NonEmptyString64 = string & NonEmptyString64Brand
 /**
  * A string that is at least 1 character long and a maximum of 64.
  */
-export const NonEmptyString64 = nonEmptyString.pipe(
+export interface NonEmptyString64Schema extends BrandedStringSchema<NonEmptyString64> {}
+export const NonEmptyString64: NonEmptyString64Schema = nonEmptyString.pipe(
   S.check(S.isMaxLength(64)),
   fromBrand<NonEmptyString64>(nominal<NonEmptyString64>(), {
     identifier: "NonEmptyString64",
@@ -81,7 +86,8 @@ export type NonEmptyString80 = string & NonEmptyString80Brand
  * A string that is at least 1 character long and a maximum of 80.
  */
 
-export const NonEmptyString80 = nonEmptyString.pipe(
+export interface NonEmptyString80Schema extends BrandedStringSchema<NonEmptyString80> {}
+export const NonEmptyString80: NonEmptyString80Schema = nonEmptyString.pipe(
   S.check(S.isMaxLength(80)),
   fromBrand<NonEmptyString80>(nominal<NonEmptyString80>(), {
     identifier: "NonEmptyString80",
@@ -103,7 +109,8 @@ export type NonEmptyString100 = string & NonEmptyString100Brand
 /**
  * A string that is at least 1 character long and a maximum of 100.
  */
-export const NonEmptyString100 = nonEmptyString.pipe(
+export interface NonEmptyString100Schema extends BrandedStringSchema<NonEmptyString100> {}
+export const NonEmptyString100: NonEmptyString100Schema = nonEmptyString.pipe(
   S.check(S.isMaxLength(100)),
   fromBrand<NonEmptyString100>(nominal<NonEmptyString100>(), {
     identifier: "NonEmptyString100",
@@ -125,7 +132,8 @@ export type Min3String255 = string & Min3String255Brand
 /**
  * A string that is at least 3 character long and a maximum of 255.
  */
-export const Min3String255 = pipe(
+export interface Min3String255Schema extends BrandedStringSchema<Min3String255> {}
+export const Min3String255: Min3String255Schema = pipe(
   S.String,
   S.check(S.isMinLength(3), S.isMaxLength(255)),
   fromBrand<Min3String255>(nominal<Min3String255>(), {
@@ -145,12 +153,22 @@ export interface StringIdBrand extends Simplify<B.Brand<"StringId"> & NonEmptySt
  */
 export type StringId = string & StringIdBrand
 
-const makeStringId = (s?: string): StringId =>
-  s !== undefined ? S.decodeSync(StringId)(s) : nanoid() as unknown as StringId
 const minLength = 6
 const maxLength = 50
 const size = 21
 const length = 10 * size
+/** Base `StringId` codec (without constructor default extensions). */
+const StringIdSchemaBase = pipe(
+  S.String,
+  S.check(S.isMinLength(minLength), S.isMaxLength(maxLength)),
+  fromBrand<StringId>(nominal<StringId>(), {
+    identifier: "StringId",
+    toArbitrary: () => (fc) => StringIdArb()(fc),
+    jsonSchema: {}
+  })
+)
+const makeStringId = (s?: string): StringId =>
+  s !== undefined ? S.decodeSync(StringIdSchemaBase)(s) : nanoid() as unknown as StringId
 const StringIdArb = (): S.LazyArbitrary<StringId> => (fc) =>
   fc
     .uint8Array({ minLength: length, maxLength: length })
@@ -161,16 +179,12 @@ const StringIdArb = (): S.LazyArbitrary<StringId> => (fc) =>
  * `.withConstructorDefault` => fresh `nanoid()` (construction-only; not
  * applied during decode — see file-level note).
  */
-export const StringId = extendM(
-  pipe(
-    S.String,
-    S.check(S.isMinLength(minLength), S.isMaxLength(maxLength)),
-    fromBrand<StringId>(nominal<StringId>(), {
-      identifier: "StringId",
-      toArbitrary: () => (fc) => StringIdArb()(fc),
-      jsonSchema: {}
-    })
-  ),
+export interface StringIdSchema extends BrandedStringSchema<StringId> {
+  readonly make: (s?: string) => StringId
+  readonly withConstructorDefault: WithConstructorDefaultSchema<StringId>
+}
+export const StringId: StringIdSchema = extendM(
+  StringIdSchemaBase,
   (s) => ({
     make: makeStringId,
     /**
@@ -209,7 +223,7 @@ export function prefixedStringId<Type extends StringId>() {
         (x) => (pref + x.substring(0, 50 - pref.length)) as Type
       )
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const s = StringId
+    const s = StringIdSchemaBase
       .pipe(
         S.refine((x: string): x is Type => x.startsWith(pref), {
           identifier: name
@@ -241,7 +255,7 @@ export function prefixedStringId<Type extends StringId>() {
          * file-level note.
          */
         withConstructorDefault: schema.pipe(
-          S.withConstructorDefault<S.Codec<Type, string> & S.WithoutConstructorDefault>(
+          S.withConstructorDefault<ConstructorDefaultBaseSchema<Type>>(
             Effect.sync(make)
           )
         )
@@ -258,18 +272,9 @@ export function prefixedStringId<Type extends StringId>() {
  */
 export const brandedStringId = <
   Id
->() =>
+>(): BrandedStringIdSchema<Id> =>
   withDefaultMake(
-    Object.assign(Object.create(StringId), StringId) as S.Codec<Id, string> & {
-      /**
-       * Construction-only default: fresh `nanoid()`-shaped id. Applied only
-       * when the field is omitted from `.make(...)` input. NOT applied
-       * during decode — cannot be used to JIT-migrate database fields. See
-       * file-level note.
-       */
-      withConstructorDefault: S.withConstructorDefault<S.Codec<Id, string> & S.WithoutConstructorDefault>
-      make: () => Id
-    } & WithDefaults<S.Codec<Id, string>>
+    Object.assign(Object.create(StringId), StringId) as BrandedStringIdSchema<Id>
   )
 
 export interface PrefixedStringUtils<
@@ -286,7 +291,12 @@ export interface PrefixedStringUtils<
    * field is omitted from `.make(...)` input. NOT applied during decode —
    * cannot be used to JIT-migrate database fields. See file-level note.
    */
-  readonly withConstructorDefault: S.withConstructorDefault<S.Codec<Type, string> & S.WithoutConstructorDefault>
+  readonly withConstructorDefault: WithConstructorDefaultSchema<Type>
+}
+
+export interface BrandedStringIdSchema<Id> extends S.Codec<Id, string>, WithDefaults<S.Codec<Id, string>> {
+  readonly withConstructorDefault: WithConstructorDefaultSchema<Id>
+  readonly make: () => Id
 }
 
 export interface UrlBrand extends Simplify<B.Brand<"Url"> & NonEmptyStringBrand> {}
@@ -297,7 +307,8 @@ const isUrl: Refinement<string, Url> = (s: string): s is Url => {
   return validator.default.isURL(s, { require_tld: false })
 }
 
-export const Url = S
+export interface UrlSchema extends BrandedStringSchema<Url> {}
+export const Url: UrlSchema = S
   .String
   .pipe(
     S.annotate({

package/src/Schema/numbers.ts

@@ -13,14 +13,20 @@ import * as Effect from "effect/Effect"
 import * as S from "effect/Schema"
 import type { Simplify } from "effect/Types"
 import { fromBrand, nominal } from "./brand.js"
-import { withDefaultMake } from "./ext.js"
+import { withDefaultMake, type WithDefaults } from "./ext.js"
 import { type B } from "./schema.js"
 
+type BrandedNumberSchema<A extends number> = S.Codec<A, number> & WithDefaults<S.Codec<A, number>>
+type BrandedNumberSchemaWithConstructorDefault<A extends number> = BrandedNumberSchema<A> & {
+  readonly withConstructorDefault: S.Codec<A, number>
+}
+
 export interface PositiveIntBrand
   extends Simplify<B.Brand<"PositiveInt"> & NonNegativeIntBrand & PositiveNumberBrand>
 {}
 /** Positive integer. `.withConstructorDefault` => `1` (construction-only). */
-export const PositiveInt = extendM(
+export interface PositiveIntSchema extends BrandedNumberSchemaWithConstructorDefault<PositiveInt> {}
+export const PositiveInt: PositiveIntSchema = extendM(
   S.Int.pipe(
     S.check(S.isGreaterThan(0)),
     fromBrand<PositiveInt>(nominal<PositiveInt>(), { identifier: "PositiveInt", jsonSchema: {} }),
@@ -39,7 +45,8 @@ export type PositiveInt = number & PositiveIntBrand
 
 export interface NonNegativeIntBrand extends Simplify<B.Brand<"NonNegativeInt"> & IntBrand & NonNegativeNumberBrand> {}
 /** Non-negative integer. `.withConstructorDefault` => `0` (construction-only). */
-export const NonNegativeInt = extendM(
+export interface NonNegativeIntSchema extends BrandedNumberSchemaWithConstructorDefault<NonNegativeInt> {}
+export const NonNegativeInt: NonNegativeIntSchema = extendM(
   S.Int.pipe(
     S.check(S.isGreaterThanOrEqualTo(0)),
     fromBrand<NonNegativeInt>(nominal<NonNegativeInt>(), {
@@ -61,7 +68,8 @@ export type NonNegativeInt = number & NonNegativeIntBrand
 
 export interface IntBrand extends Simplify<B.Brand<"Int">> {}
 /** Integer. `.withConstructorDefault` => `0` (construction-only). */
-export const Int = extendM(
+export interface IntSchema extends BrandedNumberSchemaWithConstructorDefault<Int> {}
+export const Int: IntSchema = extendM(
   S.Int.pipe(fromBrand<Int>(nominal<Int>(), { identifier: "Int", jsonSchema: {} }), withDefaultMake),
   (s) => ({
     /**
@@ -76,7 +84,8 @@ export type Int = number & IntBrand
 
 export interface PositiveNumberBrand extends Simplify<B.Brand<"PositiveNumber"> & NonNegativeNumberBrand> {}
 /** Positive finite number. `.withConstructorDefault` => `1` (construction-only). */
-export const PositiveNumber = extendM(
+export interface PositiveNumberSchema extends BrandedNumberSchemaWithConstructorDefault<PositiveNumber> {}
+export const PositiveNumber: PositiveNumberSchema = extendM(
   S.Finite.pipe(
     S.check(S.isGreaterThan(0)),
     fromBrand<PositiveNumber>(nominal<PositiveNumber>(), {
@@ -98,7 +107,8 @@ export type PositiveNumber = number & PositiveNumberBrand
 
 export interface NonNegativeNumberBrand extends Simplify<B.Brand<"NonNegativeNumber">> {}
 /** Non-negative finite number. `.withConstructorDefault` => `0` (construction-only). */
-export const NonNegativeNumber = extendM(
+export interface NonNegativeNumberSchema extends BrandedNumberSchemaWithConstructorDefault<NonNegativeNumber> {}
+export const NonNegativeNumber: NonNegativeNumberSchema = extendM(
   S
     .Finite
     .pipe(

package/src/Schema/strings.ts

@@ -2,11 +2,14 @@ import type * as B from "effect/Brand"
 import * as S from "effect/Schema"
 import type { Simplify } from "effect/Types"
 import { fromBrand, nominal } from "./brand.js"
-import { withDefaultMake } from "./ext.js"
+import { withDefaultMake, type WithDefaults } from "./ext.js"
+
+type BrandedStringSchema<A extends string> = S.Codec<A, string> & WithDefaults<S.Codec<A, string>>
 
 export type NonEmptyStringBrand = B.Brand<"NonEmptyString">
 export type NonEmptyString = string & NonEmptyStringBrand
-export const NonEmptyString = S
+export interface NonEmptyStringSchema extends BrandedStringSchema<NonEmptyString> {}
+export const NonEmptyString: NonEmptyStringSchema = S
   .NonEmptyString
   .pipe(
     fromBrand<NonEmptyString>(nominal<NonEmptyString>(), {
@@ -18,7 +21,8 @@ export const NonEmptyString = S
 
 export interface NonEmptyString64kBrand extends Simplify<B.Brand<"NonEmptyString64k"> & NonEmptyStringBrand> {}
 export type NonEmptyString64k = string & NonEmptyString64kBrand
-export const NonEmptyString64k = S
+export interface NonEmptyString64kSchema extends BrandedStringSchema<NonEmptyString64k> {}
+export const NonEmptyString64k: NonEmptyString64kSchema = S
   .NonEmptyString
   .pipe(
     S.check(S.isMaxLength(64 * 1024)),
@@ -31,7 +35,8 @@ export const NonEmptyString64k = S
 
 export interface NonEmptyString2kBrand extends Simplify<B.Brand<"NonEmptyString2k"> & NonEmptyString64kBrand> {}
 export type NonEmptyString2k = string & NonEmptyString2kBrand
-export const NonEmptyString2k = S
+export interface NonEmptyString2kSchema extends BrandedStringSchema<NonEmptyString2k> {}
+export const NonEmptyString2k: NonEmptyString2kSchema = S
   .NonEmptyString
   .pipe(
     S.check(S.isMaxLength(2 * 1024)),
@@ -44,7 +49,8 @@ export const NonEmptyString2k = S
 
 export interface NonEmptyString255Brand extends Simplify<B.Brand<"NonEmptyString255"> & NonEmptyString2kBrand> {}
 export type NonEmptyString255 = string & NonEmptyString255Brand
-export const NonEmptyString255 = S
+export interface NonEmptyString255Schema extends BrandedStringSchema<NonEmptyString255> {}
+export const NonEmptyString255: NonEmptyString255Schema = S
   .NonEmptyString
   .pipe(
     S.check(S.isMaxLength(255)),