@afora/core 0.0.9 → 0.0.11

package/dist/core/application/start.js

@@ -0,0 +1,162 @@
+import { InvalidCommandDeclaration } from "../command/exceptions.js";
+import {
+  isEnvironment,
+  loadEnvironments
+} from "../environment/environment.js";
+import { Kind } from "../symbols/kind.js";
+import {
+  ApplicationNotStarted,
+  InvalidApplicationDeclaration
+} from "./exceptions.js";
+export function providerFrom(environmentDependencies, create) {
+  if (typeof environmentDependencies === "function" && create === undefined) {
+    return Object.freeze({
+      [Kind]: "provider-factory",
+      environments: Object.freeze([]),
+      create: environmentDependencies,
+      withContext: true
+    });
+  }
+  const list = isEnvironment(environmentDependencies) ? [environmentDependencies] : Array.isArray(environmentDependencies) ? [...environmentDependencies] : [null];
+  if (!list.every(isEnvironment) || new Set(list).size !== list.length || typeof create !== "function") {
+    throw new InvalidApplicationDeclaration({
+      source: "providerFrom",
+      details: {
+        reason: "Expected distinct environments made by environmentOf and a create function."
+      }
+    });
+  }
+  return Object.freeze({
+    [Kind]: "provider-factory",
+    environments: Object.freeze(list),
+    create,
+    withContext: false
+  });
+}
+export function logFrom(create) {
+  if (typeof create !== "function") {
+    throw new InvalidApplicationDeclaration({
+      source: "logFrom",
+      details: { reason: "Expected logFrom to take a create function." }
+    });
+  }
+  return Object.freeze({ [Kind]: "log-factory", create });
+}
+export function isLogFactory(value) {
+  return typeof value === "object" && value !== null && value[Kind] === "log-factory";
+}
+export function isProviderFactory(value) {
+  return typeof value === "object" && value !== null && value[Kind] === "provider-factory";
+}
+const deferred = new WeakMap;
+const METHODS = [
+  "findOne",
+  "findMany",
+  "insert",
+  "update",
+  "remove",
+  "count"
+];
+export function deferredProvider(factory, application) {
+  const state = {
+    factory,
+    application,
+    provider: undefined,
+    starting: undefined
+  };
+  const real = (method) => {
+    const { provider } = state;
+    if (!provider) {
+      throw new ApplicationNotStarted({
+        source: application,
+        details: { application }
+      });
+    }
+    if (typeof provider[method] !== "function") {
+      throw new InvalidApplicationDeclaration({
+        source: application,
+        details: {
+          reason: `The provider made on start has no "${method}".`
+        }
+      });
+    }
+    return provider;
+  };
+  const proxy = {};
+  for (const method of [...METHODS, "increment"]) {
+    proxy[method] = (...args) => real(method)[method]?.(...args);
+  }
+  proxy.transaction = (run) => real("transaction").transaction(run);
+  proxy.migrate = async (...args) => {
+    const { provider } = state;
+    if (!provider)
+      real("migrate");
+    return provider?.migrate?.(...args);
+  };
+  Object.defineProperty(proxy, "capabilities", {
+    get: () => state.provider?.capabilities,
+    enumerable: true
+  });
+  Object.freeze(proxy);
+  deferred.set(proxy, state);
+  return proxy;
+}
+export function isDeferredProvider(provider) {
+  return typeof provider === "object" && provider !== null && deferred.has(provider);
+}
+export function deferredEnvironments(provider) {
+  return (typeof provider === "object" && provider !== null ? deferred.get(provider)?.factory.environments : undefined) ?? [];
+}
+export function startDeferred(provider, context) {
+  const state = deferred.get(provider);
+  if (!state)
+    return;
+  state.starting ??= (async () => {
+    const made = await state.factory.create(state.factory.withContext ? context : loadEnvironments(state.factory.environments));
+    if (typeof made !== "object" || made === null) {
+      state.starting = undefined;
+      throw new InvalidApplicationDeclaration({
+        source: state.application,
+        details: {
+          reason: "Expected providerFrom's create to give a repository provider."
+        }
+      });
+    }
+    state.provider = made;
+    return made;
+  })();
+  return state.starting;
+}
+export async function stopProvider(provider) {
+  const state = deferred.get(provider);
+  if (!state) {
+    await provider.close?.();
+    return;
+  }
+  const made = state.provider;
+  state.provider = undefined;
+  state.starting = undefined;
+  await made?.close?.();
+}
+export function checkTransactions(source, provider, commands) {
+  if (commands.length === 0)
+    return;
+  if (typeof provider.transaction !== "function" || provider.capabilities?.transactions === false) {
+    throw new InvalidCommandDeclaration({
+      source,
+      details: {
+        reason: `The provider made on start does not support transactions, which ${commands.join(", ")} declare.`
+      }
+    });
+  }
+}
+export function checkCapabilities(source, provider, repositories) {
+  if (repositories.length === 0 || provider.capabilities?.keyset === true)
+    return;
+  throw new InvalidApplicationDeclaration({
+    source,
+    details: {
+      reason: `The provider made on start does not read by cursor (capabilities.keyset), which the findCursor of ${repositories.join(", ")} needs.`
+    }
+  });
+}

package/dist/core/application/types/application.interface.d.ts

@@ -11,6 +11,7 @@ import type { ProviderDescription, RepositoryIndex, RepositoryScans } from "../.
 import type { AnyRepository, IRepositoryProvider } from "../../repository/types/repository.interface.js";
 import type { SchemaLock, SchemaMigrationOptions, SchemaMigrationReport } from "../../repository/types/schema.interface.js";
 import type { Kind } from "../../symbols/kind.js";
+import type { ITracer } from "../../tracing/tracing.js";
 import type { UseCaseStepDescription } from "../../use-case/steps/types/steps.interface.js";
 import type { AccessDeclaration } from "../../use-case/types/access.interface.js";
 import type { RouteDeclaration } from "../../use-case/types/route.interface.js";
@@ -101,6 +102,14 @@ export interface ApplicationSettings<Name extends string, Extended extends reado
      * it, the one of the last extended application that has one; none by default.
      */
     readonly log?: LogSettings | LogFactory;
+    /**
+     * What traces it: a span per command operation, use case and repository
+     * call made through a use case, nested as the calls are, with names and
+     * outcomes and never a value (see `docs/tracing.md`). `otelTracer()` of
+     * `@afora/otel` gives one for OpenTelemetry. Without it, the one of the
+     * last extended application that has one; none by default.
+     */
+    readonly trace?: ITracer;
     /**
      * Where event policies such as `publishEvents` publish, by key: a
      * WebSocket hub, a queue, a broker. Commands of the application find them
@@ -239,11 +248,17 @@ export interface IApplication<Name extends string, Collections extends Applicati
 export interface ApplicationStartOptions {
     /**
      * Become the started application of the process (what `useApplication()`
-     * gives). Default `true`; another one already started throws
-     * `ApplicationAlreadyStarted`.
+     * gives). Another one already started throws `ApplicationAlreadyStarted`.
+     *
+     * @default true
      */
     readonly register?: boolean;
-    /** Stop the started application of the process and take its place, e.g. on hot reload. Default `false`. */
+    /**
+     * Stop the started application of the process and take its place, e.g. on hot
+     * reload.
+     *
+     * @default false
+     */
     readonly replace?: boolean;
     /**
      * The committed schema lock (`afora.lock.json`): start throws
@@ -318,6 +333,7 @@ export type FieldDescription = {
     readonly optional: boolean;
     readonly variants: Readonly<Record<string, FieldDescription>>;
 };
+/** The fields of a blueprint, record or entity in a description, by name. */
 export type FieldsDescription = Readonly<Record<string, FieldDescription>>;
 /** A record or an entity: its fields (an entity's identity and its plugins' keys left out), options and plugins. */
 export interface RecordDescription {
@@ -485,6 +501,10 @@ export interface ApplicationDescription {
     readonly log?: LogDescription | {
         readonly kind: "opaque";
     };
+    /** Present, and opaque, only when it has a `trace` (its own or inherited). */
+    readonly trace?: {
+        readonly kind: "opaque";
+    };
     /** Its publishers (inherited ones included), by key, with the application that declared each; present only when it has some. */
     readonly publishers?: Readonly<Record<string, {
         readonly from: string;

package/dist/core/auth/jwt.js

@@ -0,0 +1,200 @@
+import { ExceptionLayers } from "../exception/enums/exception-layers.js";
+import { exceptionOf } from "../exception/exception.js";
+import { Unauthenticated } from "../output/exceptions.js";
+export const InvalidJwtOptions = exceptionOf({
+  layer: ExceptionLayers.Output,
+  name: "InvalidJwtOptions",
+  message: ({ reason }) => reason
+});
+const HASHES = {
+  HS256: "SHA-256",
+  HS384: "SHA-384",
+  HS512: "SHA-512"
+};
+const MIN_SECRET = 32;
+const DEFAULT_EXPIRES_IN = 900;
+const REGISTERED = new Set([
+  "sub",
+  "scope",
+  "iat",
+  "exp",
+  "nbf",
+  "iss",
+  "aud",
+  "use"
+]);
+const encoder = new TextEncoder;
+const decoder = new TextDecoder;
+function base64url(bytes) {
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function bytesOf(text) {
+  if (!/^[A-Za-z0-9_-]*$/.test(text))
+    return;
+  try {
+    const binary = atob(text.replaceAll("-", "+").replaceAll("_", "/"));
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0;i < binary.length; i++)
+      bytes[i] = binary.charCodeAt(i);
+    return bytes;
+  } catch {
+    return;
+  }
+}
+function jsonOf(part) {
+  const bytes = bytesOf(part);
+  if (!bytes)
+    return;
+  try {
+    const value = JSON.parse(decoder.decode(bytes));
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+  } catch {
+    return;
+  }
+}
+export function jwtOptionsIssue(options, where, extra = [], described = false) {
+  if (typeof options !== "object" || options === null || Array.isArray(options)) {
+    return `Expected ${where} to be { secret, issuer?, audience?, expiresIn?, algorithm? }.`;
+  }
+  const given = options;
+  const known = [
+    "secret",
+    "issuer",
+    "audience",
+    "expiresIn",
+    "algorithm",
+    ...extra
+  ];
+  for (const key of Object.keys(given)) {
+    if (!known.includes(key))
+      return `${where} has no option "${key}".`;
+  }
+  const { secret, issuer, audience, expiresIn, algorithm } = given;
+  const named = typeof secret === "object" && secret !== null && !Array.isArray(secret) ? secret : undefined;
+  if (named ? Object.keys(named).join() !== "env" || typeof named.env !== "string" || named.env === "" : typeof secret !== "string") {
+    return `Expected ${where}.secret to be the secret or { "env": "NAME" }.`;
+  }
+  if (described && !named) {
+    return `Expected ${where}.secret to be { "env": "NAME" }: these options are described, so the secret is named, not written.`;
+  }
+  if (typeof secret === "string" && secret.length < MIN_SECRET) {
+    return `Expected ${where}.secret to have at least ${MIN_SECRET} characters.`;
+  }
+  for (const [key, value] of [
+    ["issuer", issuer],
+    ["audience", audience]
+  ]) {
+    if (value !== undefined && (typeof value !== "string" || value === "")) {
+      return `Expected ${where}.${key} to be a non-empty string.`;
+    }
+  }
+  if (expiresIn !== undefined && (!Number.isInteger(expiresIn) || expiresIn <= 0)) {
+    return `Expected ${where}.expiresIn to be a whole number of seconds above 0.`;
+  }
+  if (algorithm !== undefined && !Object.hasOwn(HASHES, algorithm)) {
+    return `Expected ${where}.algorithm to be one of ${Object.keys(HASHES).join(", ")}.`;
+  }
+  return;
+}
+export function jwtOf(options) {
+  const issue = jwtOptionsIssue(options, "jwtOf");
+  if (issue) {
+    throw new InvalidJwtOptions({
+      source: "jwtOf",
+      details: { reason: issue }
+    });
+  }
+  const algorithm = options.algorithm ?? "HS256";
+  const lifetime = options.expiresIn ?? DEFAULT_EXPIRES_IN;
+  const header = base64url(encoder.encode(JSON.stringify({ alg: algorithm, typ: "JWT" })));
+  let imported;
+  const keyOf = () => {
+    if (imported)
+      return imported;
+    let secret;
+    if (typeof options.secret === "string")
+      secret = options.secret;
+    else {
+      const name = options.secret.env;
+      secret = globalThis.process?.env?.[name];
+      if (typeof secret !== "string" || secret.length < MIN_SECRET) {
+        throw new InvalidJwtOptions({
+          source: "jwtOf",
+          details: {
+            reason: `The environment variable ${name} must hold a secret of at least ${MIN_SECRET} characters.`
+          }
+        });
+      }
+    }
+    imported = crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: HASHES[algorithm] }, false, ["sign", "verify"]);
+    return imported;
+  };
+  const refused = () => {
+    throw new Unauthenticated({ source: "jwt" });
+  };
+  const jwt = {
+    async sign(subject, token = {}) {
+      const now = Math.floor(Date.now() / 1000);
+      const payload = {
+        ...subject.claims ?? {},
+        sub: subject.subject,
+        scope: (subject.scopes ?? []).join(" "),
+        iat: now,
+        exp: now + (token.expiresIn ?? lifetime),
+        ...options.issuer === undefined ? {} : { iss: options.issuer },
+        ...options.audience === undefined ? {} : { aud: options.audience },
+        ...token.use === undefined ? {} : { use: token.use }
+      };
+      const signing = `${header}.${base64url(encoder.encode(JSON.stringify(payload)))}`;
+      const signature = await crypto.subtle.sign("HMAC", await keyOf(), encoder.encode(signing));
+      return `${signing}.${base64url(new Uint8Array(signature))}`;
+    },
+    async verify(token, expected = {}) {
+      if (typeof token !== "string")
+        return refused();
+      const parts = token.split(".");
+      if (parts.length !== 3)
+        return refused();
+      const [head, body, sign] = parts;
+      if (jsonOf(head)?.alg !== algorithm)
+        return refused();
+      const signature = bytesOf(sign);
+      if (!signature)
+        return refused();
+      const valid = await crypto.subtle.verify("HMAC", await keyOf(), signature, encoder.encode(`${head}.${body}`));
+      const payload = valid ? jsonOf(body) : undefined;
+      if (!payload)
+        return refused();
+      const now = Math.floor(Date.now() / 1000);
+      const { sub, scope, exp, nbf, iss, aud, use } = payload;
+      if (typeof sub !== "string" || sub === "" || typeof exp !== "number" || exp <= now || nbf !== undefined && (typeof nbf !== "number" || nbf > now) || options.issuer !== undefined && iss !== options.issuer || options.audience !== undefined && aud !== options.audience && !(Array.isArray(aud) && aud.includes(options.audience)) || use !== expected.use) {
+        return refused();
+      }
+      const claims = {};
+      for (const [key, value] of Object.entries(payload)) {
+        if (!REGISTERED.has(key))
+          claims[key] = value;
+      }
+      return {
+        subject: sub,
+        scopes: typeof scope === "string" && scope !== "" ? scope.split(" ") : [],
+        ...Object.keys(claims).length > 0 ? { claims } : {}
+      };
+    },
+    authenticator(reading = {}) {
+      const header = (reading.header ?? "authorization").toLowerCase();
+      const { cookie } = reading;
+      return async (request) => {
+        const sent = request.header(header);
+        const token = sent !== undefined ? sent.replace(/^Bearer +/i, "").trim() : cookie !== undefined ? request.cookie(cookie) : undefined;
+        if (token === undefined || token === "")
+          return null;
+        return jwt.verify(token);
+      };
+    }
+  };
+  return Object.freeze(jwt);
+}

package/dist/core/auth/types/jwt.interface.d.ts

@@ -16,9 +16,17 @@ export interface JwtOptions {
     readonly issuer?: string;
     /** The `aud` claim: set when signing, required when verifying. */
     readonly audience?: string;
-    /** The seconds a token lives: 900 (15 minutes) by default. */
+    /**
+     * The seconds a token lives.
+     *
+     * @default 900
+     */
     readonly expiresIn?: number;
-    /** `"HS256"` by default. */
+    /**
+     * The algorithm the tokens are signed and verified with.
+     *
+     * @default "HS256"
+     */
     readonly algorithm?: JwtAlgorithm;
 }
 /** What a token is signed for. */

package/dist/core/blueprint/blueprint-plugin.js

@@ -0,0 +1,7 @@
+export function blueprintPluginOf(name, properties, factories = {}) {
+  return Object.freeze({
+    name,
+    properties: Object.freeze({ ...properties }),
+    factories: Object.freeze({ ...factories })
+  });
+}

package/dist/core/blueprint/blueprint.js

@@ -0,0 +1,146 @@
+import { Type } from "typebox";
+import { collectionParserOf } from "../parse/parse.js";
+import { isProperty } from "../property/is-property.js";
+import { propertyOf } from "../property/property.js";
+import { rawTypeOf, schemaOf } from "../schema/schema.js";
+import { withStandard } from "../standard/standard.js";
+import { Kind } from "../symbols/kind.js";
+import { callableOf, fieldOf } from "./callable.js";
+import {
+  ReservedBlueprintKey,
+  UndeclaredBlueprintProperty
+} from "./exceptions.js";
+import { isBlueprint } from "./is-blueprint.js";
+import { isBlueprintList, listOf } from "./list.js";
+import { optionalOf } from "./optional.js";
+import { recordFieldOf } from "./record-field.js";
+import { blueprintOfVariant, isBlueprintVariant, variantOf } from "./variant.js";
+export function blueprintBuilderOf(...base) {
+  return (sourcesOrDefine, maybeDefine) => {
+    const [sources, define] = typeof sourcesOrDefine === "function" ? [[], sourcesOrDefine] : [
+      sourcesOrDefine,
+      maybeDefine
+    ];
+    const all = [...base, ...sources];
+    return create(all.flatMap((source) => isBlueprint(source) ? source.plugins : [source]), { ...define(contextOf(all)) });
+  };
+}
+export function blueprintFromProperties(plugins, properties) {
+  return create(plugins, { ...properties });
+}
+function create(plugins, properties) {
+  const shape = {};
+  for (const [key, field] of Object.entries(properties)) {
+    properties[key] = fieldOf(field);
+    shape[key] = schemaOfField(key, properties[key]);
+  }
+  const SchemaConstructor = schemaOf("blueprint", Type.Object(shape));
+  const safeParse = collectionParserOf(properties, "blueprint");
+  const blueprint = {
+    [Kind]: "blueprint",
+    plugins: Object.freeze([...new Set(plugins)]),
+    properties: Object.freeze(properties),
+    schema: new SchemaConstructor,
+    optional: false,
+    safeParse,
+    join: (...others) => create([blueprint, ...others].flatMap((source) => source.plugins), Object.assign({}, ...[blueprint, ...others].map((source) => source.properties)))
+  };
+  return Object.freeze(withStandard(blueprint, safeParse));
+}
+const HELPERS = { listOf, optionalOf, propertyOf, variantOf };
+const RESERVED_KEYS = ["optional", "list", ...Object.keys(HELPERS)];
+function lazyMirror(keys, make) {
+  const fields = {};
+  for (const key of keys) {
+    let field;
+    Object.defineProperty(fields, key, {
+      get: () => {
+        field ??= make(key);
+        return field;
+      },
+      enumerable: true
+    });
+  }
+  return fields;
+}
+function contextOf(sources) {
+  for (const key of RESERVED_KEYS) {
+    const reserving = sources.find((source) => Object.hasOwn(source.properties, key));
+    if (reserving) {
+      throw new ReservedBlueprintKey({
+        source: isBlueprint(reserving) ? "blueprint" : reserving.name,
+        details: { key }
+      });
+    }
+  }
+  const factories = Object.assign({}, ...sources.map((source) => isBlueprint(source) ? {} : source.factories ?? {}));
+  for (const key of RESERVED_KEYS) {
+    if (Object.hasOwn(factories, key)) {
+      const reserving = sources.find((source) => !isBlueprint(source) && Object.hasOwn(source.factories ?? {}, key));
+      throw new ReservedBlueprintKey({
+        source: reserving.name,
+        details: { key }
+      });
+    }
+  }
+  const available = Object.assign({}, ...sources.map((source) => source.properties));
+  for (const key of Object.keys(factories))
+    delete available[key];
+  const mirror = (fields, map) => Object.fromEntries(Object.entries(fields).map(([key, field]) => [key, map(field)]));
+  const callable = (field) => isProperty(field) ? callableOf(field) : field;
+  const keys = Object.keys(available);
+  const list = lazyMirror(keys, (key) => listOf(available[key]));
+  const optional = lazyMirror(keys, (key) => callable(optionalOf(available[key])));
+  const listOptional = Object.freeze(lazyMirror(keys, (key) => optionalOf(list[key])));
+  Object.defineProperty(list, "optional", {
+    value: listOptional,
+    enumerable: true
+  });
+  return Object.freeze({
+    ...mirror(available, callable),
+    ...factories,
+    ...HELPERS,
+    optional: Object.freeze(optional),
+    list: Object.freeze(list)
+  });
+}
+function schemaOfField(key, field) {
+  if (isBlueprintList(field)) {
+    const { item, minItems, maxItems } = field;
+    const schema = Type.Array(schemaOfField(key, item), {
+      ...minItems === undefined ? {} : { minItems },
+      ...maxItems === undefined ? {} : { maxItems }
+    });
+    return field.optional ? Type.Optional(schema) : schema;
+  }
+  if (isBlueprint(field)) {
+    const schema = rawTypeOf(field.schema);
+    return field.optional ? Type.Optional(schema) : schema;
+  }
+  if (isBlueprintVariant(field)) {
+    const schema = Type.Union(Object.entries(field.variants).map(([tag, variant]) => {
+      const object = rawTypeOf(blueprintOfVariant(variant).schema);
+      return {
+        ...object,
+        properties: {
+          [field.key]: Type.Literal(tag),
+          ...object.properties
+        },
+        required: [field.key, ...object.required ?? []]
+      };
+    }));
+    return field.optional ? Type.Optional(schema) : schema;
+  }
+  const record = recordFieldOf(field);
+  if (record) {
+    const schema = rawTypeOf(record.record.blueprint.schema);
+    return record.optional ? Type.Optional(schema) : schema;
+  }
+  if (isProperty(field)) {
+    return rawTypeOf(field.type.schema);
+  }
+  throw new UndeclaredBlueprintProperty({
+    source: "blueprint",
+    details: { key }
+  });
+}

package/dist/core/blueprint/callable.js

@@ -0,0 +1,13 @@
+import { isProperty } from "../property/is-property.js";
+import { refinePropertyOf } from "../property/refine.js";
+const targets = new WeakMap;
+export function callableOf(Property) {
+  const callable = new Proxy(Property, {
+    apply: (target, _this, [options]) => refinePropertyOf(target, options ?? {})
+  });
+  targets.set(callable, Property);
+  return callable;
+}
+export function fieldOf(field) {
+  return (isProperty(field) ? targets.get(field) : undefined) ?? field;
+}

package/dist/core/blueprint/exceptions.js

@@ -0,0 +1,20 @@
+import { ExceptionLayers } from "../exception/enums/exception-layers.js";
+import { exceptionOf } from "../exception/exception.js";
+export const ReservedBlueprintKey = exceptionOf({
+  layer: ExceptionLayers.Blueprint,
+  name: "ReservedBlueprintKey",
+  message: ({ key }) => `"${key}" is reserved and cannot be a plugin property.`
+});
+export const InvalidBlueprintVariant = exceptionOf({
+  layer: ExceptionLayers.Blueprint,
+  name: "InvalidBlueprintVariant",
+  message: ({
+    key,
+    reason
+  }) => `The variant field of key "${key}" cannot be declared: ${reason}.`
+});
+export const UndeclaredBlueprintProperty = exceptionOf({
+  layer: ExceptionLayers.Blueprint,
+  name: "UndeclaredBlueprintProperty",
+  message: ({ key }) => `Property "${key}" of the blueprint is not declared.`
+});

package/dist/core/blueprint/is-blueprint.js

@@ -0,0 +1,4 @@
+import { Kind } from "../symbols/kind.js";
+export function isBlueprint(value) {
+  return typeof value === "object" && value !== null && value[Kind] === "blueprint";
+}

package/dist/core/blueprint/list.js

@@ -0,0 +1,19 @@
+import { parseField } from "../parse/parse.js";
+import { withStandard } from "../standard/standard.js";
+import { Kind } from "../symbols/kind.js";
+import { fieldOf } from "./callable.js";
+export function listOf(item, { minItems, maxItems } = {}) {
+  return standardListOf({
+    [Kind]: "list",
+    item: fieldOf(item),
+    optional: false,
+    minItems,
+    maxItems
+  });
+}
+export function standardListOf(list) {
+  return Object.freeze(withStandard(list, (value) => parseField(list, value, [], "list")));
+}
+export function isBlueprintList(value) {
+  return typeof value === "object" && value !== null && value[Kind] === "list";
+}