functionalscript 0.42.0 → 0.43.0

package/fjs/bnf/data/module.f.d.ts

@@ -11,7 +11,7 @@ export type TerminalRange = number;
  */
 export type Sequence = readonly string[];
 /** A variant of rule names. */
-export type Variant = StringMap<string, string>;
+export type Variant = StringMap<string>;
 /**
  * Grammar rule definition.
  *
@@ -29,7 +29,7 @@ export type RuleSet = Readonly<Record<string, Rule>>;
  * variant branch.
  */
 export type EmptyTag = string | true | undefined;
-type EmptyTagMap = StringMap<string, EmptyTag>;
+type EmptyTagMap = StringMap<EmptyTag>;
 /**
  * Computes, for every rule in the set, whether it can match empty input, by
  * the standard nullable-set fixpoint: a sequence is nullable iff all of its

package/fjs/bnf/ll1/module.f.d.ts

@@ -26,7 +26,7 @@ type DispatchRuleCollection = {
     readonly tag: string | undefined;
     readonly rules: DispatchRuleOrName[];
 };
-type DispatchMap = StringMap<string, DispatchRule>;
+type DispatchMap = StringMap<DispatchRule>;
 /**
  * Represents a parsed AST sequence.
  */

package/fjs/bnf/module.f.d.ts

@@ -89,7 +89,7 @@ export declare const range: (ab: string) => TerminalRange;
 /**
  * A set of terminal ranges compatible with the `Variant` rule.
  */
-export type RangeVariant = StringMap<string, TerminalRange>;
+export type RangeVariant = StringMap<TerminalRange>;
 export declare const remove: (range: TerminalRange, v: RangeVariant) => RangeVariant;
 /**
  * Returns the complement set of the provided ranges over {@link fullRange}.

package/fjs/cas/evo/module.f.d.ts

@@ -119,7 +119,7 @@ export type SubjectState = {
 };
 /** In-memory index: subject → its {@link SubjectState}. */
 export type Cache = {
-    readonly bySubject: StringMap<string, SubjectState>;
+    readonly bySubject: StringMap<SubjectState>;
 };
 /** A cache with no known subjects yet — the starting point for {@link buildCache}. */
 export declare const emptyCache: Cache;

package/fjs/dev/module.f.d.ts

@@ -10,7 +10,7 @@ export type Module = {
     readonly proof?: unknown;
     readonly [k: string]: unknown;
 };
-export type ModuleMap = StringMap<string, Module>;
+export type ModuleMap = StringMap<Module>;
 /**
  * Returns `true` if the file should be loaded for proof discovery.
  *

package/fjs/effects/node/module.f.d.ts

@@ -109,7 +109,7 @@ export type Stat = readonly ['stat', (path: string) => IoResult<FileStat>];
 export declare const stat: Func<Stat>;
 export type Fs = Mkdir | ReadFile | ReadBytes | Readdir | WriteFile | Rm | Rename | Exec | Access | CreateExclusive | WriteBytes | Stat;
 export type Server = Nominal<'server', `160855c4f69310fece3273c1853ac32de43dee1eb41bf59d821917f8eebe9272`, unknown>;
-export type Headers = StringMap<string, string>;
+export type Headers = StringMap<string>;
 export type IncomingMessage = {
     readonly method: string;
     readonly url: string;
@@ -129,7 +129,7 @@ export declare const listen: Func<Listen>;
 export type Http = CreateServer | Listen;
 export type Forever = ['forever', () => never];
 export declare const forever: Func<Forever>;
-export type Module = StringMap<string, unknown>;
+export type Module = StringMap<unknown>;
 export type Import = ['import', (path: string) => IoResult<Module>];
 export declare const import_: Func<Import>;
 /** Named output streams accepted by the `Write` effect. */

package/fjs/fsm/module.f.d.ts

@@ -9,7 +9,7 @@ import { type ByteSet } from '../types/byte_set/module.f.ts';
 import { type RangeMapArray } from '../types/range_map/module.f.ts';
 type Rule = readonly [string, ByteSet, string];
 export type Grammar = List<Rule>;
-type Dfa = StringMap<string, RangeMapArray<string>>;
+type Dfa = StringMap<RangeMapArray<string>>;
 export declare const toRange: (s: string) => ByteSet;
 export declare const toUnion: (s: string) => ByteSet;
 export declare const dfa: (grammar: Grammar) => Dfa;

package/fjs/media/html/module.f.d.ts

@@ -17,7 +17,7 @@ type Element2 = readonly [Tag, Attributes, ...Node[]];
  * - `[tag, attributes, ...children]` for elements with attributes.
  */
 export type Element = Element1 | Element2;
-type Attributes = StringMap<string, string>;
+type Attributes = StringMap<string>;
 export type Node = Element | string;
 /**
  * Converts a FunctionalScript element into a list of HTML string chunks.

package/fjs/types/object/module.f.d.ts

@@ -1,12 +1,35 @@
 import { type List } from '../list/module.f.ts';
 import { type Nullable } from '../nullable/module.f.ts';
 import { type OrderedMap } from '../ordered_map/module.f.ts';
-export type Map<T> = StringMap<string, T>;
+/** A record over the keys of `K`, each value possibly missing at runtime. */
+export type OptionalMap<K extends string, T> = {
+    readonly [k in K]?: T;
+};
+/**
+ * A record over the keys of `K`, each value required.
+ *
+ * `K` has to be a finite union of string literals: `RequiredMap<string, T>` is
+ * `never`, because no object can carry every string as a key. Use `StringMap<T>`
+ * for an open key set — its values are optional, which is what such a key set
+ * means at runtime.
+ *
+ * There is no known way to ask TypeScript whether `K` is finite, so the guard
+ * approximates it with `string extends K`, which holds exactly when `K` is
+ * `string`. Other infinite key sets are not caught: a template literal such as
+ * `x-${string}` yields a template index signature instead of `never`, and its
+ * reads are typed `T` while the runtime value is `undefined`. Keep `K` a union
+ * of string literals.
+ */
+export type RequiredMap<K extends string, T> = string extends K ? never : {
+    readonly [k in K]: T;
+};
+/** A record with an open key set. Every value can be missing at runtime. */
+export type StringMap<T> = OptionalMap<string, T>;
 export type Entry<T> = readonly [string, T];
-export declare const at: (name: string) => <T>(object: Map<T>) => Nullable<Exclude<T, undefined>>;
+export declare const at: (name: string) => <T>(object: StringMap<T>) => Nullable<Exclude<T, undefined>>;
 export declare const sort: <T>(e: List<Entry<T>>) => List<Entry<T>>;
-export declare const fromEntries: <T>(e: List<Entry<T>>) => Map<T>;
-export declare const fromMap: <T>(m: OrderedMap<T>) => Map<T>;
+export declare const fromEntries: <T>(e: List<Entry<T>>) => StringMap<T>;
+export declare const fromMap: <T>(m: OrderedMap<T>) => StringMap<T>;
 /**
  * A set of objects with a single key.
  *
@@ -14,7 +37,7 @@ export declare const fromMap: <T>(m: OrderedMap<T>) => Map<T>;
  * https://stackoverflow.com/questions/57571664/typescript-type-for-an-object-with-only-one-key-no-union-type-allowed-as-a-key
  */
 export type OneKey<K extends string, V> = {
-    [P in K]: (StringMap<P, V> & Partial<StringMap<Exclude<K, P>, never>>) extends infer O ? {
+    [P in K]: (RequiredMap<P, V> & OptionalMap<Exclude<K, P>, never>) extends infer O ? {
         [Q in keyof O]: O[Q];
     } : never;
 }[K];
@@ -24,13 +47,8 @@ export type OneKey<K extends string, V> = {
 export type NotUnion<T, U = T> = T extends unknown ? [
     U
 ] extends [T] ? T : never : never;
-export type SingleProperty<T extends StringMap<string, never>> = keyof T extends NotUnion<keyof T> ? T : never;
+export type SingleProperty<T extends StringMap<never>> = keyof T extends NotUnion<keyof T> ? T : never;
 export declare const isObject: (value: unknown) => value is { readonly [k in string]: unknown; };
 /** Returns only the defined (non-undefined) values of a partial record. */
-export declare const definedValues: <T>(map: StringMap<string, Exclude<T, undefined>>) => readonly Exclude<T, undefined>[];
-export type StringMap<K extends string, T> = string extends K ? {
-    readonly [k in string]?: T;
-} : {
-    readonly [k in K]: T;
-};
-export declare const definedEntries: <T>(cmd: StringMap<string, Exclude<T, undefined>>) => readonly (readonly [string, Exclude<T, undefined>])[];
+export declare const definedValues: <T>(map: StringMap<Exclude<T, undefined>>) => readonly Exclude<T, undefined>[];
+export declare const definedEntries: <T>(cmd: StringMap<Exclude<T, undefined>>) => readonly (readonly [string, Exclude<T, undefined>])[];

package/fjs/types/object/module.f.js

@@ -1,7 +1,8 @@
 /**
- * Plain-object helpers and types: `Map<T>`/`Entry<T>` shapes, safe property
- * lookup via `at`, conversions between entries and `OrderedMap`, and the
- * `OneKey`/`SingleProperty`/`NotUnion` utility types.
+ * Plain-object helpers and types: the `OptionalMap`/`RequiredMap`/`StringMap`
+ * record shapes and `Entry<T>`, safe property lookup via `at`, conversions
+ * between entries and `OrderedMap`, and the `OneKey`/`SingleProperty`/`NotUnion`
+ * utility types.
  *
  * @module
  */

package/fjs/types/object/proof.f.d.ts

@@ -1,18 +1,4 @@
-import type { StringMap } from './module.f.ts';
-type E<A, B> = A extends B ? B extends A ? true : false : false;
-type _InfiniteIsOptional = E<StringMap<string, bigint>, {
-    readonly [k in string]?: bigint;
-}>;
-type _FiniteIsRequired = E<StringMap<'a' | 'b', bigint>, {
-    readonly a: bigint;
-    readonly b: bigint;
-}>;
 export declare const proof: {
-    stringMap: {
-        infiniteIsOptional: _InfiniteIsOptional;
-        finiteIsRequired: _FiniteIsRequired;
-    };
     ctor: () => void;
     property: () => void;
 };
-export {};

package/fjs/types/object/proof.f.js

@@ -1,10 +1,6 @@
 import { at } from './module.f.js';
 import { assertEq } from '../../asserts/module.f.js';
 export const proof = {
-    stringMap: {
-        infiniteIsOptional: true,
-        finiteIsRequired: true,
-    },
     ctor: () => {
         const a = {};
         const value = at('constructor')(a);

package/fjs/types/rtti/common/module.f.d.ts

@@ -74,11 +74,11 @@ export type Visitor<R> = {
 /** Type guard narrowing `Unknown` to a specific container type `C`. */
 export type IsContainer<C extends Unknown> = (value: Unknown) => value is C;
 /** Maps a `Tag1` to its runtime container type. */
-export type Container<K extends Tag1> = K extends 'array' ? ReadonlyArray<Unknown> : StringMap<string, Unknown>;
+export type Container<K extends Tag1> = K extends 'array' ? ReadonlyArray<Unknown> : StringMap<Unknown>;
 /** `IsContainer` guard for arrays, shared by `validate` and `parse`. */
 export declare const isArray: IsContainer<ReadonlyArray<Unknown>>;
 /** `IsContainer` guard for records/structs, shared by `validate` and `parse`. */
-export declare const isObject: IsContainer<StringMap<string, Unknown>>;
+export declare const isObject: IsContainer<StringMap<Unknown>>;
 /**
  * Runs `item` over each `[key, value]` entry, bailing out with the first
  * error, path-prefixed with that entry's key. On success, folds each item's

package/fjs/types/rtti/module.f.d.ts

@@ -6,7 +6,7 @@ export type Const = null | boolean | number | string | undefined | bigint | {
 } | readonly Type[];
 export type ConstObject = Struct | Tuple;
 /** A struct schema: plain object whose values are nested `Type`s. */
-export type Struct = StringMap<string, Type>;
+export type Struct = StringMap<Type>;
 /** A tuple schema: readonly array whose elements are nested `Type`s. */
 export type Tuple = readonly Type[];
 declare const primitive0List: readonly ['bigint', 'boolean', 'number', 'string'];

package/fjs/types/rtti/ts/module.f.d.ts

@@ -31,7 +31,7 @@ export type Object = {
 /** Maps a `Tag0` to its TypeScript type. */
 export type Info0Ts<T extends Tag0> = T extends 'boolean' ? boolean : T extends 'number' ? number : T extends 'string' ? string : T extends 'bigint' ? bigint : T extends 'unknown' ? Unknown : never;
 /** Maps a `Const` schema to its TypeScript type. */
-export type ConstTs<T> = T extends readonly Type[] ? TupleTs<T> : T extends StringMap<string, Type> ? StructTs<T> : T;
+export type ConstTs<T> = T extends readonly Type[] ? TupleTs<T> : T extends StringMap<Type> ? StructTs<T> : T;
 /** Maps a `Tag1` and inner type to its TypeScript type. */
 export type Info1Ts<K extends Tag1, T extends Type> = K extends 'array' ? ArrayTs<T> : K extends 'record' ? RecordTs<T> : never;
 /** Maps an array schema `T` to `readonly Ts<T>[]`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.42.0",
+  "version": "0.43.0",
   "type": "module",
   "files": [
     "**/*.js",