@allyhub/sdk 0.1.0-alpha.8 → 0.2.0-next.1

package/node_modules/@allyhub-next/video-core/dist/marks.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+const x={"**":"strong","*":"em","~~":"strike","`":"code"},g=/\\([\\*~`])|\*\*|~~|\*|`/g,k=/\s/u;function m(i){const o=[];let d=0;for(const e of i.matchAll(g)){if(e.index>d&&o.push({kind:"text",text:i.slice(d,e.index)}),d=e.index+e[0].length,e[1]!==void 0){o.push({kind:"escape",text:e[1]});continue}const s=i[e.index-1],u=i[d];o.push({kind:"delim",text:e[0],opens:u!==void 0&&!k.test(u),closes:s!==void 0&&!k.test(s)})}return d<i.length&&o.push({kind:"text",text:i.slice(d)}),o}export const hasMarks=i=>/[*~`\\]/.test(i);export function readMarks(i){if(!hasMarks(i))return{text:i,marks:[]};const o=m(i),d=[];for(let t=0;t<o.length;t++){const n=o[t];if(n?.kind!=="delim")continue;if(n.text==="`"){const c=o.findIndex((p,h)=>h>t&&p.kind==="delim"&&p.text==="`");if(c<0)continue;const a=o[c];n.pair=c,a?.kind==="delim"&&(a.pair=t),t=c;continue}let r=-1;if(n.closes)for(let c=d.length-1;c>=0&&r<0;c--)o[d[c]??-1]?.text===n.text&&(r=c);const f=d[r],l=f===void 0?void 0:o[f];f!==void 0&&l?.kind==="delim"&&f<t-1?(l.pair=t,n.pair=f,d.length=r):n.opens&&d.push(t)}let e="";const s=[],u=new Map;for(let t=0;t<o.length;t++){const n=o[t];if(!n)continue;if(n.kind!=="delim"){e+=n.text;continue}if(n.pair===void 0){e+=n.text;continue}const r=x[n.text];if(r===void 0)continue;if(n.pair>t){if(u.set(t,e.length),r!=="code")continue;for(let l=t+1;l<n.pair;l++){const c=o[l];c&&(e+=c.kind==="escape"?`\\${c.text}`:c.text)}t=n.pair-1;continue}const f=u.get(n.pair);f!==void 0&&e.length>f&&s.push({at:f,end:e.length,kind:r})}return s.sort((t,n)=>t.at-n.at||n.end-t.end),{text:e,marks:s}}export const withoutMarks=i=>readMarks(i).text;const M=["strong","em","strike","code"];export function markRuns(i,o=[]){const d=[...new Set([0,i.length,...o.flatMap(s=>[s.at,s.end])])].filter(s=>s>=0&&s<=i.length).sort((s,u)=>s-u),e=[];return d.forEach((s,u)=>{const t=d[u+1];if(t===void 0||t<=s)return;const n=o.filter(r=>r.at<=s&&t<=r.end);e.push({text:i.slice(s,t),kinds:M.filter(r=>n.some(f=>f.kind===r))})}),e}

package/node_modules/@allyhub-next/video-core/dist/matrix.d.ts

@@ -0,0 +1,289 @@
+import type { VideoFormat } from "./formats.js";
+/** One point of the matrix: dimension or slot → value, e.g. { lang: "en", hook: "price" }. */
+export type Combo = Record<string, string>;
+/** Dimensions → values, in the order they were declared. */
+export type Dims = Record<string, string[]>;
+/** A candidate of a slot, with tags rules can name (`#price`). */
+export interface Candidate {
+    name: string;
+    tags?: string[];
+}
+/** A slot whose candidates are the media files of a folder: one per file, named by its stem. */
+export interface PoolSlot {
+    /** The folder, relative to the piece's file. */
+    pool: string;
+    /** Tags every file of the pool has (a file's `<stem>.meta.json` may add its own). */
+    tags?: string[];
+}
+/** A slot's candidates: names (or names with tags), or a pool folder. */
+export type SlotDecl = readonly (string | Candidate)[] | PoolSlot;
+/** A condition's value: a name, `#tag`, or any of several. */
+export type MatchValue = string | readonly string[];
+/** Slot, dimension or `structure` → the value it must have. */
+export type Conditions = Record<string, MatchValue>;
+/**
+ * A rule: when every `if` condition holds (or there is no `if`), every
+ * `require` condition must hold and no `exclude` condition may.
+ */
+export interface MatrixRule {
+    if?: Conditions;
+    require?: Conditions;
+    exclude?: Conditions;
+}
+/** How different any two chosen combos must be. */
+export interface Differ {
+    /** In at least this many slots (a different structure counts as one). */
+    slots?: number;
+    /**
+     * Their openings differ: the first n slots of each structure, or these
+     * slots, are not all the same.
+     */
+    first?: readonly string[] | number;
+}
+/** A piece's `matrix`: plain data. */
+export interface Matrix {
+    /** Dimensions, crossed in full with every chosen slot combination. */
+    dims?: Dims;
+    /** Slots and their candidates (`ctx.combo.<slot>` is the pick). */
+    slots?: Record<string, SlotDecl>;
+    /** Named orders of slots; default: one structure of every slot in order. */
+    structures?: Record<string, readonly string[]>;
+    /**
+     * The slot combinations to make, chosen by the agent: each names its
+     * structure (when the piece declares structures) and one candidate per
+     * slot of it. Ids c01… in this order. Nothing is sampled, so `pick` and
+     * `seed` cannot be given with it.
+     */
+    combos?: readonly Combo[];
+    /** How many slot combinations sampling chooses; default: every one the rules allow. */
+    pick?: number;
+    /** Seeds sampling's choice among equally good combinations; default 1. */
+    seed?: number | string;
+    differ?: Differ;
+    rules?: readonly MatrixRule[];
+}
+/** Names a dimension or slot cannot have. */
+export declare const RESERVED_DIMS: readonly ["size", "format", "piece", "output", "token", "structure", "id"];
+/** The combo key of a matrix's structure, when it declares structures. */
+export declare const STRUCTURE = "structure";
+/**
+ * The combo key: names sorted, `name=value` joined by commas, e.g.
+ * `hook=price,lang=en`. `default` when there are none.
+ */
+export declare function comboKey(c: Combo): string;
+/** `lang=zh-cn,opening=hook` → { lang: "zh-cn", opening: "hook" }. */
+export declare function parseComboKey(key: string): Combo;
+/** Every combo of the dimensions, the first values first. */
+export declare function expandCombos(dims: Dims): Combo[];
+/** A filter's key for a combo id (`--combo c03`). */
+export declare const COMBO_ID = "#id";
+/**
+ * Whether a combo matches a filter: every given name equal. A filter
+ * `{ "#id": "c03" }` matches the combo whose id is `id`.
+ */
+export declare function comboMatches(c: Combo, filter: Combo, id?: string): boolean;
+/**
+ * The key the runtime's random seed is built from: the combo key with the
+ * format in it as `size=<format>` (`size` is never a dimension). A part's
+ * seed is "piece id + output + this key (of the dimensions only) + part
+ * key + frame number in the part".
+ */
+export declare function seedKey(c: Combo, format: string): string;
+/** The defaults the framework fills in: languages and formats. */
+export interface MatrixDefaults {
+    /** Locales of assets/text/, the default first. */
+    locales: readonly string[];
+    /** Formats of a piece that does not declare `formats`. */
+    formats: readonly VideoFormat[];
+}
+/**
+ * A piece's dimensions as the framework uses them: `lang` from the
+ * messages files when the piece does not say (and there are messages).
+ * Declared dimensions keep their order and values.
+ */
+export declare function resolveDims(declared: Dims | undefined, defaults: Pick<MatrixDefaults, "locales">): Dims;
+/** A candidate as the build resolved it. */
+export interface SlotCandidate {
+    name: string;
+    tags: string[];
+    /** A pool's file, relative to the project. */
+    file?: string;
+}
+/** The slots and structures a combo is made of, as the build resolved them. */
+export interface MatrixSpace {
+    /** Slot → candidates, in declared order. */
+    slots: Record<string, SlotCandidate[]>;
+    /** Structure → its slots in order (one implicit "default" when none are declared). */
+    structures: Record<string, string[]>;
+    /** The piece declares structures: every combo names its own (`combo.structure`). */
+    declared: boolean;
+}
+/** Whether the piece has slots. */
+export declare const hasSlots: (space: MatrixSpace | undefined) => space is MatrixSpace;
+/** The structures a matrix's slots make: its own, or every slot in order. */
+export declare function structuresOf(slots: readonly string[], declared: Record<string, readonly string[]> | undefined): Record<string, string[]>;
+/** The structure a combo has. */
+export declare function structureOf(space: MatrixSpace, c: Combo): string | undefined;
+/** The slots of a combo, in its structure's order. */
+export declare function slotsOf(space: MatrixSpace, c: Combo): string[];
+/** The slot part of a combo: its structure (when declared) and its picks. */
+export declare function slotCombo(space: MatrixSpace, c: Combo): Combo;
+/** The dimension part of a combo. */
+export declare function dimsCombo(dims: Dims, c: Combo): Combo;
+/** Conditions as people read them: `hook=#price cta=sale|trial`. */
+export declare function conditionsText(c: Conditions | undefined): string;
+/** A rule as people read it: `if hook=#price require cta=sale`. */
+export declare function ruleText(r: MatrixRule): string;
+type Verdict = "yes" | "no" | "unknown";
+/**
+ * Whether a point keeps a rule: "no" when it breaks it, "unknown" when that
+ * depends on a dimension the point does not have yet.
+ */
+export declare function keepsRule(space: MatrixSpace, dims: Dims, rule: MatrixRule, point: Combo): Verdict;
+/** Whether a point keeps every rule (unknown counts as kept). */
+export declare function keepsRules(space: MatrixSpace, dims: Dims, rules: readonly MatrixRule[], point: Combo): boolean;
+/** Whether a combo is one the matrix can make: its dimensions, structure and picks are known, and it keeps the rules. */
+export declare function validCombo(space: MatrixSpace | undefined, dims: Dims, rules: readonly MatrixRule[], c: Combo): boolean;
+/**
+ * What is wrong with a matrix's slots, structures, rules, pick and differ
+ * (AK-X001), as sentences; empty when nothing is.
+ */
+export declare function matrixProblems(space: MatrixSpace, dims: Dims, m: Pick<Matrix, "rules" | "differ" | "structures">): string[];
+/** A chosen slot combination: its id, picks and why it was chosen. */
+export interface MatrixPick {
+    /** c01, c02…: the order it was chosen in. */
+    id: string;
+    /** The structure (when the piece declares structures) and one candidate per slot. */
+    combo: Combo;
+    /** Why it was chosen, in a few words each. */
+    why: string[];
+}
+export interface Sampled {
+    picks: MatrixPick[];
+    /** Slot combinations before the rules, and those the rules allow. */
+    total: number;
+    valid: number;
+    /** Pairs of picks closer than `differ` allows (when it could not hold). */
+    tooClose: {
+        a: string;
+        b: string;
+        slots: number;
+        opening: boolean;
+    }[];
+    /** Candidates in no pick (slot → names). */
+    unused: Record<string, string[]>;
+}
+/** The most slot combinations sampling looks at. */
+export declare const MAX_COMBINATIONS = 100000;
+/** How many slot combinations the structures make, before the rules. */
+export declare function combinationCount(space: MatrixSpace): number;
+/** In how many slots two slot combinations differ (a different structure counts as one). */
+export declare function comboDistance(space: MatrixSpace, a: Combo, b: Combo): number;
+/** The id of the nth pick (from 0): c01… with as many digits as the count needs. */
+export declare function pickId(n: number, count: number): string;
+/**
+ * Chooses `pick` slot combinations the rules allow, deterministic for the
+ * same definition. Greedy, best first:
+ *
+ * 1. combinations that keep `differ` against every earlier pick (when none
+ *    is left, the closest-to-keeping one, reported in `tooClose`);
+ * 2. that use the most candidates (and structures) no pick uses yet, so
+ *    every candidate appears at least once when it can;
+ * 3. whose candidates are used least so far, so use spreads evenly;
+ * 4. that make the most pairs of picks not seen together yet;
+ * 5. that differ most from the nearest earlier pick;
+ * 6. then the seed decides.
+ */
+export declare function sampleMatrix(space: MatrixSpace, dims: Dims, m: Pick<Matrix, "pick" | "seed" | "differ" | "rules">): Sampled;
+/**
+ * What is wrong with the names of matrix.combos (AK-X001), as sentences:
+ * a structure, slot or candidate that does not exist, a slot of its
+ * structure it lacks, or a dimension (dimensions are crossed with every
+ * combo). Empty when nothing is.
+ */
+export declare function combosProblems(space: MatrixSpace, dims: Dims, combos: readonly Combo[]): string[];
+/** The combos matrix.combos chose, with what the rules and differ say of them. */
+export interface ChosenPicks {
+    /** In the given order: c01, c02… */
+    picks: MatrixPick[];
+    /** Slot combinations before the rules. */
+    total: number;
+    /**
+     * Those the rules allow; absent when the slots make more than
+     * MAX_COMBINATIONS, which are not counted.
+     */
+    valid?: number;
+    /** Picks a rule rules out (AK-X002): the pick's id and the rules' numbers, from 1. */
+    broken: {
+        id: string;
+        rules: number[];
+    }[];
+    /**
+     * Pairs of picks closer than `differ` allows, or the same (AK-X004).
+     * Without differ, only the same combo twice.
+     */
+    tooClose: Sampled["tooClose"];
+    /** Candidates in no pick (slot → names). */
+    unused: Record<string, string[]>;
+}
+/**
+ * The picks matrix.combos names, in its order, each with its structure
+ * (when the piece declares structures) and its slots in the structure's
+ * order. Expects names combosProblems finds nothing wrong with.
+ */
+export declare function chosenPicks(space: MatrixSpace, dims: Dims, m: Pick<Matrix, "combos" | "differ" | "rules">): ChosenPicks;
+/** A combo the piece makes: its id (pieces with slots), key and the pick it crosses. */
+export interface ChosenCombo {
+    /** c01, or c01-zh-cn when there are several points of the dimensions. */
+    id: string;
+    combo: Combo;
+    /** The slot pick's id (c01). */
+    pick: string;
+}
+/**
+ * The chosen picks crossed with every combo of the dimensions, keeping
+ * the rules that name dimensions. Ids add the dimensions' values when
+ * there is more than one combo of them.
+ */
+export declare function crossPicks(space: MatrixSpace, dims: Dims, rules: readonly MatrixRule[], picks: readonly MatrixPick[]): {
+    combos: ChosenCombo[];
+    dropped: Combo[];
+};
+/** A piece's matrix as the build resolved and sampled it (pieces with slots). */
+export interface MatrixPlan {
+    space: MatrixSpace;
+    rules: MatrixRule[];
+    /** How the slot combinations were chosen: named in matrix.combos, or sampled. */
+    choice: "combos" | "sampling";
+    /** What the piece asked sampling for. */
+    pick?: number;
+    seed?: number | string;
+    differ?: Differ;
+    /** The chosen slot combinations, in order. */
+    picks: MatrixPick[];
+    /** The picks crossed with the dimensions: what is checked and rendered. */
+    combos: ChosenCombo[];
+    /** Slot combinations before the rules. */
+    total: number;
+    /**
+     * Those the rules allow; absent when matrix.combos chose among more
+     * than MAX_COMBINATIONS, which are not counted.
+     */
+    valid?: number;
+    /** Crossings a rule naming a dimension left out. */
+    dropped: Combo[];
+    tooClose: Sampled["tooClose"];
+    unused: Sampled["unused"];
+}
+/** A combo's id, when the piece has slots and chose it. */
+export declare function comboIdOf(plan: Pick<MatrixPlan, "combos"> | undefined, combo: Combo): string | undefined;
+/**
+ * A few combos that between them have every candidate (and structure) of
+ * the others, for each point of the dimensions: the check loads only
+ * these, since a part reads only its own slot's pick (AK-X005) and so
+ * looks the same in every combo that has it. Indexes into `combos`, in
+ * their order; greedy, the combo that adds the most first.
+ */
+export declare function coverCombos(space: MatrixSpace, dims: Dims, combos: readonly Combo[]): number[];
+export {};
+//# sourceMappingURL=matrix.d.ts.map

package/node_modules/@allyhub-next/video-core/dist/matrix.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+export const RESERVED_DIMS=["size","format","piece","output","token","structure","id"],STRUCTURE="structure";export function comboKey(t){const o=Object.keys(t).sort();return o.length===0?"default":o.map(n=>`${n}=${t[n]??""}`).join(",")}export function parseComboKey(t){if(t==="default"||t==="")return{};const o={};for(const n of t.split(",")){const e=n.indexOf("=");e<=0||(o[n.slice(0,e).trim()]=n.slice(e+1).trim())}return o}export function expandCombos(t){let o=[{}];for(const[n,e]of Object.entries(t)){const s=[];for(const i of o)for(const u of e)s.push({...i,[n]:u});o=s}return o}export const COMBO_ID="#id";export function comboMatches(t,o,n){return Object.entries(o).every(([e,s])=>e===COMBO_ID?n===s||(n?.startsWith(`${s}-`)??!1):t[e]===s)}export function seedKey(t,o){return comboKey({...t,size:o})}export function resolveDims(t,o){const n={};(!t||!("lang"in t))&&o.locales.length>0&&(n.lang=[...o.locales]);for(const[e,s]of Object.entries(t??{}))n[e]=[...s];return n}export const hasSlots=t=>t!==void 0&&Object.keys(t.slots).length>0;export function structuresOf(t,o){return o&&Object.keys(o).length>0?Object.fromEntries(Object.entries(o).map(([n,e])=>[n,[...e]])):t.length>0?{default:[...t]}:{}}export function structureOf(t,o){return t.declared?o[STRUCTURE]:Object.keys(t.structures)[0]}export function slotsOf(t,o){const n=structureOf(t,o);return n===void 0?[]:t.structures[n]??[]}export function slotCombo(t,o){const n={},e=structureOf(t,o);t.declared&&e!==void 0&&(n[STRUCTURE]=e);for(const s of slotsOf(t,o)){const i=o[s];i!==void 0&&(n[s]=i)}return n}export function dimsCombo(t,o){const n={};for(const e of Object.keys(t)){const s=o[e];s!==void 0&&(n[e]=s)}return n}const P=t=>typeof t=="string"?[t]:t;export function conditionsText(t){return Object.entries(t??{}).map(([o,n])=>`${o}=${P(n).join("|")}`).join(" ")}export function ruleText(t){return[t.if?`if ${conditionsText(t.if)}`:"",t.require?`require ${conditionsText(t.require)}`:"",t.exclude?`exclude ${conditionsText(t.exclude)}`:""].filter(Boolean).join(" ")}function z(t,o,n){return P(t).some(e=>e.startsWith("#")?n?.tags.includes(e.slice(1))??!1:e===o)}function E(t,o,n,e,s){if(e===STRUCTURE){const i=structureOf(t,n);return i!==void 0&&z(s,i,void 0)?"yes":"no"}if(e in t.slots){if(!slotsOf(t,n).includes(e))return"no";const i=n[e];if(i===void 0)return"no";const u=t.slots[e]?.find(c=>c.name===i);return z(s,i,u)?"yes":"no"}if(e in o){const i=n[e];return i===void 0?"unknown":z(s,i,void 0)?"yes":"no"}return"no"}const U=t=>t.includes("no")?"no":t.includes("unknown")?"unknown":"yes";export function keepsRule(t,o,n,e){const s=U(Object.entries(n.if??{}).map(([r,f])=>E(t,o,e,r,f)));if(s==="no")return"yes";const i=Object.entries(n.require??{}).map(([r,f])=>E(t,o,e,r,f)),u=Object.entries(n.exclude??{}).map(([r,f])=>{const d=E(t,o,e,r,f);return d==="yes"?"no":d==="no"?"yes":"unknown"}),c=U([...i,...u]);return c==="yes"?"yes":s==="unknown"||c==="unknown"?"unknown":"no"}export function keepsRules(t,o,n,e){return n.every(s=>keepsRule(t,o,s,e)!=="no")}export function validCombo(t,o,n,e){const s=new Set(Object.keys(e));for(const[u,c]of Object.entries(o)){if(!c.includes(e[u]??""))return!1;s.delete(u)}if(!hasSlots(t))return s.size===0;const i=structureOf(t,e);if(i===void 0||!(i in t.structures))return!1;t.declared&&s.delete(STRUCTURE);for(const u of slotsOf(t,e)){if(!t.slots[u]?.some(c=>c.name===e[u]))return!1;s.delete(u)}return s.size===0&&keepsRules(t,o,n,e)}export function matrixProblems(t,o,n){const e=[],s=Object.keys(t.slots);for(const r of s){r in o&&e.push(`${r} is both a dimension and a slot. Rename one of them.`);const f=t.slots[r]??[];f.length===0&&e.push(`Slot ${r} has no candidates.`);const d=new Set;for(const a of f)d.has(a.name)&&e.push(`Slot ${r} lists the candidate ${a.name} twice.`),d.add(a.name)}for(const[r,f]of Object.entries(n.structures??{})){f.length===0&&e.push(`Structure ${r} has no slots.`);for(const d of f)d in t.slots||e.push(`Structure ${r} names the slot ${d}, which matrix.slots does not declare (slots: ${s.join(", ")||"none"}).`);new Set(f).size!==f.length&&e.push(`Structure ${r} names a slot twice.`)}const i=new Set(Object.values(t.structures).flat());for(const r of s)i.has(r)||e.push(`Slot ${r} is in no structure. Add it to one, or remove it.`);const u=r=>r===STRUCTURE||r in t.slots||r in o;for(const[r,f]of(n.rules??[]).entries()){const d=`Rule ${String(r+1)}`,a=[f.if,f.require,f.exclude];!f.require&&!f.exclude&&e.push(`${d} has neither require nor exclude.`);for(const h of a)for(const[m,b]of Object.entries(h??{})){if(!u(m)){e.push(`${d} names ${m}, which is not a slot, a dimension or structure.`);continue}for(const $ of P(b))if(m===STRUCTURE)$ in t.structures||e.push(`${d} names the structure ${$}, which does not exist.`);else if(m in t.slots){const x=t.slots[m]??[];($.startsWith("#")?x.some(w=>w.tags.includes($.slice(1))):x.some(w=>w.name===$))||e.push($.startsWith("#")?`${d}: no candidate of ${m} has the tag ${$.slice(1)}.`:`${d}: ${m} has no candidate ${$} (candidates: ${x.map(w=>w.name).join(", ")}).`)}else(o[m]??[]).includes($)||e.push(`${d}: the dimension ${m} has no value ${$}.`)}}const c=n.differ?.first;if(Array.isArray(c))for(const r of c)r in t.slots||e.push(`differ.first names ${r}, which is not a slot.`);return e}export const MAX_COMBINATIONS=1e5;function Q(t){let o=2166136261;for(let n=0;n<t.length;n++)o^=t.charCodeAt(n),o=Math.imul(o,16777619);return o>>>0}export function combinationCount(t){let o=0;for(const n of Object.values(t.structures))o+=n.reduce((e,s)=>e*(t.slots[s]?.length??0),1);return o}function Y(t){const o=[];for(const[n,e]of Object.entries(t.structures)){let s=[t.declared?{[STRUCTURE]:n}:{}];for(const i of e){const u=[];for(const c of s)for(const r of t.slots[i]??[])u.push({...c,[i]:r.name});s=u}o.push(...s)}return o}export function comboDistance(t,o,n){let e=structureOf(t,o)===structureOf(t,n)?0:1;for(const s of Object.keys(t.slots)){const i=slotsOf(t,o).includes(s)?o[s]:void 0,u=slotsOf(t,n).includes(s)?n[s]:void 0;i!==u&&e++}return e}function T(t,o,n){return n===void 0?void 0:(typeof n=="number"?slotsOf(t,o).slice(0,n):slotsOf(t,o).filter(s=>n.includes(s))).map(s=>`${s}=${o[s]??""}`).join(",")}export function pickId(t,o){const n=Math.max(2,String(o).length);return`c${String(t+1).padStart(n,"0")}`}const D=(t,o)=>{const n=slotsOf(t,o).map(e=>`${e}=${o[e]??""}`);return t.declared&&n.push(`${STRUCTURE}=${o[STRUCTURE]??""}`),n},Z=(t,o)=>{const n=slotsOf(t,o),e=[];for(let s=0;s<n.length;s++)for(let i=s+1;i<n.length;i++){const u=n[s]??"",c=n[i]??"";e.push(`${u}=${o[u]??""}+${c}=${o[c]??""}`)}return e};export function sampleMatrix(t,o,n){const e=combinationCount(t),s=n.rules??[],i=L(t,o,s)??[],u=Math.min(n.pick??i.length,i.length),c=String(n.seed??1),r=n.differ?.slots??1,f=n.differ?.first,a=i.map(p=>comboKey(p)).map(p=>Q(`${c}:${p}`)),h=i.map(p=>D(t,p)),m=i.map(p=>Z(t,p)),b=i.map(p=>T(t,p,f)),$=i.map(()=>1/0),x=new Set,j=new Map,w=new Set,C=new Set,v=[],I=[],N=[];for(let p=0;p<u;p++){let g=-1,R=[];for(let l=0;l<i.length;l++){if(C.has(l))continue;const O=h[l]??[],k=($[l]??1/0)>=r&&!(b[l]!==void 0&&x.has(b[l]??"")),X=O.filter(S=>!j.has(S)).length,F=O.reduce((S,J)=>S+(j.get(J)??0),0),G=(m[l]??[]).filter(S=>!w.has(S)).length,H=Math.min($[l]??1/0,1e3),K=[k?1:0,X,-F,G,H,a[l]??0];(g<0||tt(K,R))&&(g=l,R=K)}if(g<0)break;const q=i[g]??{},M=h[g]??[],y=[],W=M.filter(l=>!j.has(l));if(p===0&&y.push("first pick"),W.length>0&&p>0)y.push(`first use of ${W.join(", ")}`);else if(p>0){const l=Math.min(...M.map(k=>j.get(k)??0)),O=M.filter(k=>(j.get(k)??0)===l);y.push(`spreads use: ${O.join(", ")} used ${String(l)}× so far`)}const A=(m[g]??[]).filter(l=>!w.has(l)).length;if(p>0&&A>0&&y.push(`${String(A)} new pairing${A===1?"":"s"}`),p>0){const l=$[g]??1/0;R[0]===1?y.push(`differs from every earlier pick in ≥ ${String(l)} slot${l===1?"":"s"}`):y.push(`no combination left keeps differ; closest earlier pick is ${String(l)} slot${l===1?"":"s"} away`)}const _=pickId(p,u);for(const l of I){const O=comboDistance(t,q,i[l]??{}),k=b[g]!==void 0&&b[g]===b[l];(O<r||k)&&N.push({a:v[I.indexOf(l)]?.id??"",b:_,slots:O,opening:k})}C.add(g),I.push(g),v.push({id:_,combo:q,why:y});for(const l of M)j.set(l,(j.get(l)??0)+1);for(const l of m[g]??[])w.add(l);const B=b[g];B!==void 0&&x.add(B);for(let l=0;l<i.length;l++){if(C.has(l))continue;const O=comboDistance(t,i[l]??{},q);O<($[l]??1/0)&&($[l]=O)}}return{picks:v,total:e,valid:i.length,tooClose:N,unused:V(t,v)}}function L(t,o,n){if(!(combinationCount(t)>MAX_COMBINATIONS))return Y(t).filter(e=>keepsRules(t,o,n,e))}function V(t,o){const n=new Set(o.flatMap(s=>D(t,s.combo))),e={};for(const[s,i]of Object.entries(t.slots)){const u=i.map(c=>c.name).filter(c=>!n.has(`${s}=${c}`));u.length>0&&(e[s]=u)}return e}function tt(t,o){for(let n=0;n<t.length;n++){const e=t[n]??0,s=o[n]??0;if(e!==s)return e>s}return!1}export function combosProblems(t,o,n){const e=[],s=Object.keys(t.structures),i=Object.keys(t.slots),u=c=>(t.slots[c]??[]).map(r=>r.name).join(", ");for(const[c,r]of n.entries()){const f=`combos[${String(c)}] (${pickId(c,n.length)})`;let d;const a=r[STRUCTURE];t.declared?a===void 0?e.push(`${f} names no structure: the piece declares structures (${s.join(", ")}). Add structure.`):a in t.structures?d=t.structures[a]:e.push(`${f} names the structure ${a}, which does not exist (structures: ${s.join(", ")}).`):(a!==void 0&&e.push(`${f} names a structure, but the piece declares none. Remove it, or declare matrix.structures.`),d=Object.values(t.structures)[0]);for(const[h,m]of Object.entries(r))h!==STRUCTURE&&(h in o?e.push(`${f} names the dimension ${h}: every combo is made in each of its values. Leave a value out with a rule naming ${h}.`):h in t.slots?d&&!d.includes(h)?e.push(`${f} names the slot ${h}, which the structure ${a??""} does not have (${d.join(", ")}).`):t.slots[h]?.some(b=>b.name===m)||e.push(`${f}: ${h} has no candidate ${m} (candidates: ${u(h)}).`):e.push(`${f} names ${h}, which is not a slot (slots: ${i.join(", ")}).`));for(const h of d??[])r[h]===void 0&&e.push(`${f} has no ${h}, a slot of ${t.declared?`the structure ${a??""}`:"the piece"}. Name one of its candidates (${u(h)}).`)}return e}export function chosenPicks(t,o,n){const e=n.combos??[],s=n.rules??[],i=e.map((a,h)=>{const m={},b=structureOf(t,a);t.declared&&b!==void 0&&(m[STRUCTURE]=b);for(const $ of slotsOf(t,a)){const x=a[$];x!==void 0&&(m[$]=x)}return{id:pickId(h,e.length),combo:m,why:["chosen in matrix.combos"]}}),u=[];for(const a of i){const h=s.flatMap((m,b)=>keepsRule(t,o,m,a.combo)==="no"?[b+1]:[]);h.length>0&&u.push({id:a.id,rules:h})}const c=n.differ?.slots??1,r=n.differ?.first,f=[];for(let a=0;a<i.length;a++)for(let h=0;h<a;h++){const m=i[h],b=i[a];if(!m||!b)continue;const $=comboDistance(t,m.combo,b.combo),x=T(t,m.combo,r),j=x!==void 0&&x===T(t,b.combo,r);($<c||j)&&f.push({a:m.id,b:b.id,slots:$,opening:j})}const d=L(t,o,s);return{picks:i,total:combinationCount(t),...d===void 0?{}:{valid:d.length},broken:u,tooClose:f,unused:V(t,i)}}export function crossPicks(t,o,n,e){const s=expandCombos(o),i=s.length>1,u=[],c=[];for(const r of e)for(const f of s){const d={...f,...r.combo};if(!keepsRules(t,o,n,d)){c.push(d);continue}u.push({id:i?[r.id,...Object.values(f)].join("-"):r.id,combo:d,pick:r.id})}return{combos:u,dropped:c}}export function comboIdOf(t,o){if(!t)return;const n=comboKey(o);return t.combos.find(e=>comboKey(e.combo)===n)?.id}export function coverCombos(t,o,n){const e=n.map(u=>{const c=comboKey(dimsCombo(o,u));return D(t,u).map(r=>`${c}|${r}`)}),s=new Set(e.flat()),i=new Set;for(;s.size>0;){let u=-1,c=0;if(e.forEach((r,f)=>{if(i.has(f))return;const d=r.filter(a=>s.has(a)).length;d>c&&(u=f,c=d)}),u<0)break;i.add(u);for(const r of e[u]??[])s.delete(r)}return[...i].sort((u,c)=>u-c)}