@lokascript/framework 4.6.0 → 4.7.0

package/dist/core/matching/confidence-model.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The matcher's confidence model: an injectable score for a pattern's match
+ * (domains rethink Phase 4.3). The interface moved here with the skeleton
+ * (`match-skeleton.ts`), which calls `calculate` once per matched pattern;
+ * hyperscript's model is `@lokascript/semantic`'s `DefaultConfidenceModel`.
+ */
+import type { LanguagePattern, SemanticRole, SemanticValue } from '../types';
+/**
+ * Context passed to confidence model methods.
+ */
+export interface ConfidenceContext {
+    /** The pattern being matched */
+    readonly pattern: LanguagePattern;
+    /** Captured semantic roles */
+    readonly captured: ReadonlyMap<SemanticRole, SemanticValue>;
+    /** Number of stem (morphological) keyword matches */
+    readonly stemMatchCount: number;
+    /** Total keyword matches attempted */
+    readonly totalKeywordMatches: number;
+}
+/**
+ * Breakdown of confidence scoring factors (for diagnostics/debugging).
+ */
+export interface ConfidenceBreakdown {
+    /** Role coverage score (0-1) */
+    readonly roleCoverage: number;
+    /** Stem match penalty applied (0 to -0.15) */
+    readonly stemPenalty: number;
+    /** Language-specific boost (e.g., VSO verb-first) */
+    readonly languageBoost: number;
+    /** Language-specific adjustment (e.g., preposition disambiguation) */
+    readonly languageAdjustment: number;
+    /** Final clamped confidence (0-1) */
+    readonly final: number;
+}
+/**
+ * Injectable confidence scoring model.
+ *
+ * Each method computes one factor of the confidence score.
+ * Override individual methods to customize scoring without rewriting the pipeline.
+ */
+export interface ConfidenceModel {
+    /**
+     * Calculate the full confidence score.
+     * Default implementation calls each factor method and combines them.
+     */
+    calculate(ctx: ConfidenceContext): number;
+    /**
+     * Calculate confidence with a detailed breakdown.
+     * Useful for diagnostics and debugging.
+     */
+    calculateWithBreakdown(ctx: ConfidenceContext): ConfidenceBreakdown;
+}
+//# sourceMappingURL=confidence-model.d.ts.map

package/dist/core/matching/confidence-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confidence-model.d.ts","sourceRoot":"","sources":["../../../src/core/matching/confidence-model.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE7E;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,gCAAgC;IAChC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,8BAA8B;IAC9B,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC;IAC5D,qDAAqD;IACrD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,sCAAsC;IACtC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;CACtC;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,gCAAgC;IAChC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,8CAA8C;IAC9C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,qDAAqD;IACrD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,sEAAsE;IACtE,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,qCAAqC;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,SAAS,CAAC,GAAG,EAAE,iBAAiB,GAAG,MAAM,CAAC;IAE1C;;;OAGG;IACH,sBAAsB,CAAC,GAAG,EAAE,iBAAiB,GAAG,mBAAmB,CAAC;CACrE"}

package/dist/core/matching/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The pattern matcher's skeleton and its value-reader seam (domains rethink
+ * Phase 4.3): the matcher semantic's hyperscript parser runs, with
+ * hyperscript's reading behind `ValueReader`.
+ */
+export { MatchSkeleton } from './match-skeleton';
+export type { MatchView, RoleSlot, ValueReader } from './value-reader';
+export type { ConfidenceBreakdown, ConfidenceContext, ConfidenceModel } from './confidence-model';
+export { StockValueReader, createStockReader, greedyStopMarkers, readGreedy } from './stock-reader';
+export { readRoleValue, type ReadingProfile } from './stock-reading';
+export { stockConfidenceModel } from './stock-confidence';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/matching/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/matching/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACvE,YAAY,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAClG,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACpG,OAAO,EAAE,aAAa,EAAE,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/core/matching/match-skeleton.d.ts

@@ -0,0 +1,114 @@
+/**
+ * The pattern matcher's skeleton: the grammar-neutral half of semantic's matcher
+ * (domains rethink Phase 4.2-4.3, `docs-internal/DOMAINS_RETHINK.md`).
+ *
+ * It walks a pattern's literals, groups and role slots against the token
+ * stream: literal matching (exact, normalized, stem, case- and
+ * diacritic-insensitive, shattered compounds), optional groups with exact
+ * rollback and the marker discipline of a postpositional group, the
+ * speculative skip of an optional slot, role spans, memoized ranking by
+ * priority then confidence, the confidence model, and the extraction rules.
+ * Every value is read by the grammar's `ValueReader` (`value-reader.ts`);
+ * hyperscript's is `@lokascript/semantic`'s `HyperscriptValueReader`, and its
+ * confidence model semantic's `DefaultConfidenceModel`.
+ */
+import type { LanguagePattern, PatternMatchResult, TokenStream } from '../types';
+import type { ConfidenceModel } from './confidence-model';
+import type { MatchView, ValueReader } from './value-reader';
+export declare class MatchSkeleton {
+    /**
+     * The pattern tokens still to match after the one being matched, through
+     * every enclosing group: a value stops at any marker the pattern still owes.
+     */
+    private patternRest;
+    /**
+     * Whether the role slot being matched directly follows a literal the pattern
+     * matched: its marker (`[por {quantity}]`), or the command's verb.
+     */
+    private slotAfterLiteral;
+    /** Injectable confidence scoring model (Phase 3.3) */
+    private readonly confidenceModel;
+    /**
+     * Selective memoization cache (Phase 6.1).
+     * Caches pattern match results keyed by `tokenPosition:patternId`.
+     * Cleared before each top-level matchBest() call.
+     */
+    private matchCache;
+    /**
+     * Stream index where each role's capture began, for the current
+     * `matchPattern` call. Rebuilt per call, written on the same success path as
+     * `captured` — see `PatternMatchResult.roleStarts`.
+     */
+    private roleStarts;
+    /** The grammar's value reading: every role slot, and the grammar's hooks. */
+    private readonly reader;
+    /**
+     * @param makeReader - builds the grammar's reader, handed this matcher's view
+     *   of the match in progress (one reader per matcher).
+     */
+    constructor(makeReader: (view: MatchView) => ValueReader, confidenceModel: ConfidenceModel);
+    /**
+     * Try to match a single pattern against the token stream.
+     * Returns the match result or null if no match.
+     */
+    matchPattern(tokens: TokenStream, pattern: LanguagePattern): PatternMatchResult | null;
+    /**
+     * Try to match multiple patterns, return the best match.
+     */
+    matchBest(tokens: TokenStream, patterns: LanguagePattern[]): PatternMatchResult | null;
+    /**
+     * Match a sequence of pattern tokens against the token stream.
+     */
+    private matchTokenSequence;
+    /**
+     * Match a single pattern token against the current position in the stream.
+     */
+    private matchPatternToken;
+    /**
+     * Match a literal pattern token (keyword or particle).
+     */
+    private matchLiteralToken;
+    /**
+     * Match a compound keyword (`titik-henti`, `по_умолчанию`) against a
+     * shattered token run (`titik` `-` `henti` / `по` `_` `умолчанию`): word
+     * segments must be identifier/keyword/particle tokens equal to the expected
+     * segments (case-insensitive; particle because prepositions like ru `по` /
+     * uk `за` lead some underscore compounds), separators lone `sep` tokens.
+     * Consumes the run on success, resets the stream on failure.
+     */
+    private tryMatchShatteredCompound;
+    /**
+     * Match a group pattern token (optional sequence).
+     */
+    private matchGroupToken;
+    /**
+     * Whether a pattern token (literal, or a group starting with a literal) would
+     * match the given stream token. Used to keep the event-head source-clause
+     * consumption from stealing a marker the pattern explicitly expects.
+     */
+    private patternTokenWouldMatch;
+    /**
+     * Get the type of match for a token against a value.
+     * Used for confidence calculation.
+     */
+    private getMatchType;
+    /**
+     * Track stem matches for confidence calculation.
+     * This is set during matching and read during confidence calculation.
+     */
+    private stemMatchCount;
+    private totalKeywordMatches;
+    /**
+     * Apply extraction rules to fill in static values and defaults for missing
+     * roles, and re-shape captured roles that declare a `transform` (the
+     * ExtractionRule field was documented but unwired — go-qu-url-dest is the
+     * first consumer: it re-types the marker-bound capture to the expression
+     * shape the en reference produces).
+     */
+    private applyExtractionRules;
+    /**
+     * Check if a pattern token is optional.
+     */
+    private isOptional;
+}
+//# sourceMappingURL=match-skeleton.d.ts.map

package/dist/core/matching/match-skeleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"match-skeleton.d.ts","sourceRoot":"","sources":["../../../src/core/matching/match-skeleton.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EACV,eAAe,EAEf,kBAAkB,EAGlB,WAAW,EAEZ,MAAM,UAAU,CAAC;AAElB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAO7D,qBAAa,aAAa;IACxB;;;OAGG;IACH,OAAO,CAAC,WAAW,CAAsB;IAEzC;;;OAGG;IACH,OAAO,CAAC,gBAAgB,CAAS;IAEjC,sDAAsD;IACtD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;IAElD;;;;OAIG;IACH,OAAO,CAAC,UAAU,CAAgD;IAElE;;;;OAIG;IACH,OAAO,CAAC,UAAU,CAAmC;IAErD,6EAA6E;IAC7E,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IAErC;;;OAGG;gBACS,UAAU,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,WAAW,EAAE,eAAe,EAAE,eAAe;IAS1F;;;OAGG;IACH,YAAY,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,eAAe,GAAG,kBAAkB,GAAG,IAAI;IAyCtF;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,eAAe,EAAE,GAAG,kBAAkB,GAAG,IAAI;IAiDtF;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA+F1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA8BzB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAoDzB;;;;;;;OAOG;IACH,OAAO,CAAC,yBAAyB;IA+BjC;;OAEG;IACH,OAAO,CAAC,eAAe;IAmGvB;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAY9B;;;OAGG;IACH,OAAO,CAAC,YAAY;IAuCpB;;;OAGG;IACH,OAAO,CAAC,cAAc,CAAa;IAEnC,OAAO,CAAC,mBAAmB,CAAa;IAExC;;;;;;OAMG;IACH,OAAO,CAAC,oBAAoB;IAoC5B;;OAEG;IACH,OAAO,CAAC,UAAU;CAGnB"}

package/dist/core/matching/stock-confidence.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The stock confidence model: how framework's old matcher scored a domain
+ * pattern's match (`core/pattern-matching/`), moved here as a `ConfidenceModel`
+ * for the matcher's skeleton (domains rethink Phase 4.7); the old matcher calls
+ * it too until Phase 6.
+ *
+ * Role coverage (a required slot 1, an optional one 0.8, an absent optional one
+ * with a default 60% of that), a stem-match penalty (up to 15%, floor 0.5), and
+ * two Arabic adjustments: a VSO verb-first boost and the preposition each role
+ * takes most naturally.
+ */
+import type { ConfidenceModel } from './confidence-model';
+/** The stock confidence model (stateless: one instance serves every matcher). */
+export declare const stockConfidenceModel: ConfidenceModel;
+//# sourceMappingURL=stock-confidence.d.ts.map

package/dist/core/matching/stock-confidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stock-confidence.d.ts","sourceRoot":"","sources":["../../../src/core/matching/stock-confidence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAA0C,eAAe,EAAE,MAAM,oBAAoB,CAAC;AA4NlG,iFAAiF;AACjF,eAAO,MAAM,oBAAoB,EAAE,eAGlC,CAAC"}

package/dist/core/matching/stock-reader.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The stock value reader: what a domain grammar's matcher reads at each role
+ * slot, on the matcher's skeleton (domains rethink Phase 4.7,
+ * `docs-internal/DOMAINS_RETHINK.md`). Hyperscript's reader is semantic's
+ * `HyperscriptValueReader`; a domain takes this one.
+ *
+ * - A **greedy** slot (`RoleSpec.greedy`: a SQL condition, a column list) reads
+ *   every token up to the next marker the pattern still owes, or the end, as
+ *   one expression (`readGreedy`).
+ * - Any other slot reads one value (`readRoleValue`, the old matcher's reading):
+ *   a selector, a quoted string, a number, a boolean, a duration, a URL, an
+ *   identifier, or one of the multi-token forms it knows (`user.name`,
+ *   `#dialog.showModal()`), checked against the slot's expected types.
+ * - A **required** slot reads nothing where the stream is at the marker the
+ *   pattern wants next (the old matcher's guard against an SOV marker taken as
+ *   a value). Where a required slot finds nothing to read, and the optional,
+ *   marker-less slot just before it read a value with nothing read since, that
+ *   value is given back and the required slot reads again (the old matcher's
+ *   backtrack: behaviorspec `when clicks`, where the optional actor took
+ *   `clicks`; flow `orders として 取得変数`, where the optional patient took
+ *   `orders`).
+ * - An **optional** slot may be skipped for a token the pattern wants next, the
+ *   skip kept only when the rest of the pattern then reads to the end.
+ */
+import type { LanguagePattern, LanguageToken, PatternToken, SemanticRole, SemanticValue, TokenStream } from '../types';
+import type { MatchView, RoleSlot, ValueReader } from './value-reader';
+import { type ReadingProfile } from './stock-reading';
+/**
+ * The markers a greedy value stops at, from the pattern tokens still owed after
+ * it: the next literal (with its alternatives), and each optional group's
+ * leading literal up to and including the first required token.
+ */
+export declare function greedyStopMarkers(rest: readonly PatternToken[]): Set<string>;
+/**
+ * Read every token up to a stop marker (or the end) as one expression value,
+ * advancing past them; null (consuming nothing) when the first token stops it.
+ */
+export declare function readGreedy(tokens: TokenStream, stopMarkers: ReadonlySet<string>): SemanticValue | null;
+/** The stock reader, for a matcher whose profiles it may consult (possessive words). */
+export declare class StockValueReader implements ValueReader {
+    private readonly view;
+    private readonly profiles;
+    private profile;
+    /** The last optional, marker-less slot that read a value: what a failing required slot may take back. */
+    private lastOptional;
+    constructor(view: MatchView, profiles?: Readonly<Record<string, ReadingProfile>>);
+    beginPattern(pattern: LanguagePattern): void;
+    readRole(tokens: TokenStream, slot: RoleSlot, captured: Map<SemanticRole, SemanticValue>, next: PatternToken | undefined): boolean;
+    /** One read of `slot`; `guard` refuses a required slot the marker the pattern wants next. */
+    private readOnce;
+    maySkipSlot(patternToken: PatternToken, token: LanguageToken | null, next: PatternToken | undefined): boolean;
+    atClauseEnd(tokens: TokenStream): boolean;
+}
+/** A reader factory for `MatchSkeleton`, reading with the given profiles. */
+export declare function createStockReader(profiles?: Readonly<Record<string, ReadingProfile>>): (view: MatchView) => ValueReader;
+//# sourceMappingURL=stock-reader.d.ts.map

package/dist/core/matching/stock-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stock-reader.d.ts","sourceRoot":"","sources":["../../../src/core/matching/stock-reader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAEV,eAAe,EACf,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,WAAW,EACZ,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACvE,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAErE;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,YAAY,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAqB5E;AASD;;;GAGG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,WAAW,EACnB,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,GAC/B,aAAa,GAAG,IAAI,CAStB;AAED,wFAAwF;AACxF,qBAAa,gBAAiB,YAAW,WAAW;IAMhD,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAN3B,OAAO,CAAC,OAAO,CAA6B;IAC5C,yGAAyG;IACzG,OAAO,CAAC,YAAY,CAAqE;gBAGtE,IAAI,EAAE,SAAS,EACf,QAAQ,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAM;IAG1E,YAAY,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAK5C,QAAQ,CACN,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,GAAG,CAAC,YAAY,EAAE,aAAa,CAAC,EAC1C,IAAI,EAAE,YAAY,GAAG,SAAS,GAC7B,OAAO;IAwBV,6FAA6F;IAC7F,OAAO,CAAC,QAAQ;IAwBhB,WAAW,CACT,YAAY,EAAE,YAAY,EAC1B,KAAK,EAAE,aAAa,GAAG,IAAI,EAC3B,IAAI,EAAE,YAAY,GAAG,SAAS,GAC7B,OAAO;IAWV,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO;CAG1C;AAED,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAC/B,QAAQ,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAM,GACtD,CAAC,IAAI,EAAE,SAAS,KAAK,WAAW,CAElC"}

package/dist/core/matching/stock-reading.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Reading a domain value at a role slot: the value reading framework's old
+ * matcher (`core/pattern-matching/`) did, moved here so the stock reader on the
+ * matcher's skeleton (`stock-reader.ts`, domains rethink Phase 4.7) and the old
+ * matcher run the same code until Phase 6 deletes the old one.
+ *
+ * In order: an English noise word before a selector (`the`), then the
+ * multi-token forms (a possessive, `my value`; a method call,
+ * `#dialog.showModal()`; a possessive selector, `#el's *opacity`; a property
+ * access, `user.name`; a selector and its property, `#out.innerText`), then one
+ * token by its kind (a selector, a quoted string, a number, a boolean, a
+ * duration, a URL, an identifier). Each is checked against the slot's
+ * expected types.
+ */
+import type { PatternToken, SemanticRole, SemanticValue, TokenStream } from '../types';
+/** What value reading needs of a language profile: its code, and its possessive words. */
+export interface ReadingProfile {
+    readonly code: string;
+    readonly possessive?: {
+        readonly keywords?: Record<string, string>;
+    };
+}
+/**
+ * Safely convert a value to lowercase string.
+ * Provides protection against non-string values at runtime.
+ */
+/** `value` lower-cased, whatever it is (the old matcher's keyword compare uses it too). */
+export declare function safeToLowerCase(value: unknown): string;
+/**
+ * Match a role pattern token (captures a semantic value).
+ * Handles multi-token expressions like:
+ * - 'my value' (possessive keyword + property)
+ * - '#dialog.showModal()' (method call)
+ * - "#element's *opacity" (possessive selector + property)
+ */
+/**
+ * Read a value for `patternToken`'s role at the stream's position into
+ * `captured`, and advance past it. False when the slot does not match; an
+ * optional slot whose value does not fit returns true and captures nothing.
+ */
+export declare function readRoleValue(tokens: TokenStream, patternToken: PatternToken & {
+    type: 'role';
+}, captured: Map<SemanticRole, SemanticValue>, profile?: ReadingProfile): boolean;
+//# sourceMappingURL=stock-reading.d.ts.map

package/dist/core/matching/stock-reading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stock-reading.d.ts","sourceRoot":"","sources":["../../../src/core/matching/stock-reading.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EACV,YAAY,EAEZ,YAAY,EACZ,aAAa,EACb,WAAW,EAEZ,MAAM,UAAU,CAAC;AAKlB,0FAA0F;AAC1F,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,CAAC,EAAE;QACpB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KAC5C,CAAC;CACH;AAQD;;;GAGG;AACH,2FAA2F;AAC3F,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAQtD;AAED;;;;;;GAMG;AACH;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,WAAW,EACnB,YAAY,EAAE,YAAY,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAC7C,QAAQ,EAAE,GAAG,CAAC,YAAY,EAAE,aAAa,CAAC,EAC1C,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAwFT"}

package/dist/core/matching/value-reader.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The seam between the pattern matcher's skeleton and a grammar's value
+ * reading (domains rethink Phase 4.2-4.3, `docs-internal/DOMAINS_RETHINK.md`).
+ *
+ * The skeleton (`match-skeleton.ts`) walks a pattern: its literals, groups and
+ * role slots, with rollback, ranking, spans, memoization and the confidence
+ * model. It knows nothing of what a VALUE is in the grammar, nor of the
+ * grammar's language profiles: each role slot is read through `readRole`, and
+ * the few places the walk needs a grammar fact go through the hooks below.
+ * Hyperscript's reader is `@lokascript/semantic`'s `HyperscriptValueReader`.
+ */
+import type { LanguagePattern, LanguageToken, PatternMatchResult, PatternToken, SemanticRole, SemanticValue, TokenStream } from '../types';
+/** A role slot of a pattern. */
+export type RoleSlot = PatternToken & {
+    type: 'role';
+};
+/** What the skeleton tells its reader about the match in progress. */
+export interface MatchView {
+    /**
+     * The pattern tokens still to match after the slot being read, through every
+     * enclosing group: a value stops at any marker the pattern still owes.
+     */
+    patternRest(): readonly PatternToken[];
+    /**
+     * Whether the slot being read directly follows a literal the pattern
+     * matched: its marker (`[por {quantity}]`), or the command's verb.
+     */
+    slotAfterLiteral(): boolean;
+    /** Whether a pattern token (a literal, or a group starting with one) would match the token. */
+    wouldMatch(pt: PatternToken | undefined, token: LanguageToken): boolean;
+}
+/** A grammar's value reading, as the matcher's skeleton calls it. */
+export interface ValueReader {
+    /** A pattern is about to be matched: reset what the reader keeps per pattern. */
+    beginPattern(pattern: LanguagePattern): void;
+    /**
+     * Read a value for `slot` at the stream's position into `captured`, and
+     * advance past it. False when the slot does not match; an optional slot that
+     * reads nothing returns true, captures nothing and consumes nothing.
+     *
+     * @param next - the pattern token after the slot (through an enclosing
+     *   group's end), undefined where the pattern truly ends.
+     */
+    readRole(tokens: TokenStream, slot: RoleSlot, captured: Map<SemanticRole, SemanticValue>, next: PatternToken | undefined): boolean;
+    /**
+     * Slot discipline: may the skeleton try skipping this optional pattern token
+     * (a slot, or an optional group of slots) for the token at the stream's head?
+     * The skeleton then matches the rest of the pattern without it, and keeps the
+     * skip only when that reaches a clause end (`atClauseEnd`). For a marker-less
+     * optional slot facing a verb it must not eat.
+     */
+    maySkipSlot(patternToken: PatternToken, token: LanguageToken | null, next: PatternToken | undefined): boolean;
+    /** Does a clause end at the stream's position (its end, or the next clause's first word)? */
+    atClauseEnd(tokens: TokenStream): boolean;
+    /** Skip what the grammar reads as nothing before a sequence (Arabic proclitics). */
+    skipLeading?(tokens: TokenStream, sequence: readonly PatternToken[]): void;
+    /** Before `sequence[index]` is matched (hyperscript: an event head's source clause). */
+    beforePatternToken?(tokens: TokenStream, sequence: readonly PatternToken[], index: number, captured: Map<SemanticRole, SemanticValue>): void;
+    /** Fields the reader adds to the pattern's match result (hyperscript: `eventSource`). */
+    resultFields?(): Partial<PatternMatchResult>;
+}
+//# sourceMappingURL=value-reader.d.ts.map

package/dist/core/matching/value-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-reader.d.ts","sourceRoot":"","sources":["../../../src/core/matching/value-reader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,kBAAkB,EAClB,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,WAAW,EACZ,MAAM,UAAU,CAAC;AAElB,gCAAgC;AAChC,MAAM,MAAM,QAAQ,GAAG,YAAY,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvD,sEAAsE;AACtE,MAAM,WAAW,SAAS;IACxB;;;OAGG;IACH,WAAW,IAAI,SAAS,YAAY,EAAE,CAAC;IACvC;;;OAGG;IACH,gBAAgB,IAAI,OAAO,CAAC;IAC5B,+FAA+F;IAC/F,UAAU,CAAC,EAAE,EAAE,YAAY,GAAG,SAAS,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC;CACzE;AAED,qEAAqE;AACrE,MAAM,WAAW,WAAW;IAC1B,iFAAiF;IACjF,YAAY,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,CAAC;IAC7C;;;;;;;OAOG;IACH,QAAQ,CACN,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,GAAG,CAAC,YAAY,EAAE,aAAa,CAAC,EAC1C,IAAI,EAAE,YAAY,GAAG,SAAS,GAC7B,OAAO,CAAC;IACX;;;;;;OAMG;IACH,WAAW,CACT,YAAY,EAAE,YAAY,EAC1B,KAAK,EAAE,aAAa,GAAG,IAAI,EAC3B,IAAI,EAAE,YAAY,GAAG,SAAS,GAC7B,OAAO,CAAC;IACX,6FAA6F;IAC7F,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC;IAC1C,oFAAoF;IACpF,WAAW,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,YAAY,EAAE,GAAG,IAAI,CAAC;IAC3E,wFAAwF;IACxF,kBAAkB,CAAC,CACjB,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,SAAS,YAAY,EAAE,EACjC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,GAAG,CAAC,YAAY,EAAE,aAAa,CAAC,GACzC,IAAI,CAAC;IACR,yFAAyF;IACzF,YAAY,CAAC,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAAC;CAC9C"}