@maka/maka-cli 5.122.0 → 5.123.0

package/bundle/typescript/src/commands/game/sideQuest/utilities/catalog-data.d.ts

@@ -20,10 +20,11 @@
  * gear -- these strings are what the player reads, and what an NPC's
  * swag briefing quotes.
  */
-import type { SkillName } from '../models/player.js';
-import type { AugBonusKind } from '../augmentations.js';
-export declare const CATALOG_VERSION = 13;
-export type CatalogKind = 'gear' | 'quality' | 'spell' | 'augmentation' | 'metatype';
+import type { IQuality } from '../qualities.js';
+import type { ICatalogChoice, ICatalogRestrictions } from './effects.js';
+import type { ICatalogEffect } from './effects.js';
+export declare const CATALOG_VERSION = 14;
+export type CatalogKind = 'gear' | 'quality' | 'spell' | 'augmentation' | 'metatype' | 'adept-power' | 'metamagic';
 /** The skill a weapon is fired or swung with. The last four have no engine
  *  skill yet (SkillName); the engine falls back per models/player.ts. */
 export type WeaponSkill = 'pistols' | 'automatics' | 'longarms' | 'archery' | 'blades' | 'clubs' | 'unarmed' | 'heavy-weapons' | 'throwing-weapons' | 'exotic-melee' | 'exotic-ranged';
@@ -136,80 +137,7 @@ export interface ICatalogMod {
     /** Weapon classes it refuses: a silencer fits no revolver or shotgun (p.432). */
     excludes?: ('shotgun' | 'revolver')[];
 }
-export type EffectPool = AugBonusKind | 'pan-defense' | 'matrix-soak' | 'biofeedback' | 'toxin' | 'climbing';
-export type EffectLimit = 'physical' | 'mental' | 'social' | 'accuracy';
-export type EffectAttribute = 'body' | 'agility' | 'reaction' | 'strength' | 'willpower' | 'logic' | 'intuition' | 'charisma' | 'edge' | 'magic' | 'resonance' | 'reach' | 'armor-bonus';
-export type EffectMatrixAttribute = 'attack' | 'sleaze' | 'dataProcessing' | 'firewall' | 'damage';
-/** A capability is a flag the engine asks for by key (Player.hasCapability). */
-export type EffectCapability = 'dni' | 'smartlink' | 'smartgun' | 'low-light' | 'thermographic' | 'no-fog' | 'silenced' | 'full-body' | 'autopicker' | 'maglock-opposed';
-/**
- * A modifier the row grants while it applies. `value` is a NUMBER, never a
- * string: every reader adds it, and a string would need parsing at each
- * one and would drift in the web's seed. `scaleBy` multiplies it by the
- * row's `ratingValue` (rating), the cast Force (force) or the hits of a
- * sustained spell (hits). `when` defaults by kind: a wearable's effects
- * apply worn, a weapon's held, a program's running, a data soft's stored,
- * a mod's fitted, an augmentation's installed, a quality's held.
- */
-export type ICatalogEffect = {
-    type: 'dice';
-    category: 'skills';
-    property: SkillName;
-    value: number;
-    scaleBy?: EffectScale;
-    when?: EffectWhen;
-    only?: string;
-} | {
-    type: 'dice';
-    category: 'pools';
-    property: EffectPool;
-    value: number;
-    scaleBy?: EffectScale;
-    when?: EffectWhen;
-    only?: string;
-} | {
-    type: 'limit';
-    category: 'limits';
-    property: EffectLimit;
-    value: number;
-    scaleBy?: EffectScale;
-    when?: EffectWhen;
-    only?: string;
-} | {
-    type: 'attribute';
-    category: 'attributes';
-    property: EffectAttribute;
-    value: number;
-    scaleBy?: EffectScale;
-    when?: EffectWhen;
-    only?: string;
-} | {
-    type: 'attribute';
-    category: 'matrix';
-    property: EffectMatrixAttribute;
-    value: number;
-    scaleBy?: EffectScale;
-    when?: EffectWhen;
-    only?: string;
-} | {
-    type: 'initiative';
-    category: 'pools';
-    property: 'dice' | 'score';
-    value: number;
-    scaleBy?: EffectScale;
-    when?: EffectWhen;
-    only?: string;
-} | {
-    type: 'flag';
-    category: 'capability';
-    property: EffectCapability;
-    value: number;
-    scaleBy?: EffectScale;
-    when?: EffectWhen;
-    only?: string;
-};
-export type EffectScale = 'rating' | 'force' | 'hits';
-export type EffectWhen = 'worn' | 'held' | 'carried' | 'running' | 'stored' | 'fitted' | 'installed' | 'held-quality' | 'sustained';
+export type { EffectPool, EffectLimit, EffectAttribute, EffectMatrixAttribute, EffectCapability, ICatalogEffect, EffectScale, EffectWhen, } from './effects.js';
 /** Every kind shares this. */
 export interface ICatalogBase {
     /** Absent = 'gear'. */
@@ -222,6 +150,34 @@ export interface ICatalogBase {
     page?: string;
     approx?: boolean;
     effects?: ICatalogEffect[];
+    /**
+     * THE SPELL A FORMULA TEACHES, by spells.ts key.
+     *
+     * A spell formula is written for ONE spell (p.461, p.299: "the spell
+     * you want"), and its PRICE is set by that spell's category. The
+     * five rows here used to be the categories themselves -- "Combat
+     * Spell Formula" -- and Player.knowsSpell matched them by looking
+     * for the spell's name inside the item's name. No category name
+     * ever contains a spell name, so the match could never fire: every
+     * one of them was 500 to 2,000 nuyen for a scroll that taught
+     * nothing.
+     */
+    teaches?: string;
+    /**
+     * A pick this row cannot work without (ICatalogChoice). ON THE BASE,
+     * so a quality, an augmentation, a spell or an adept power all declare
+     * one the same way -- a Hardwire naming a skill is the same question
+     * Aptitude asks, and asking it twice in two shapes is how the picker
+     * ends up rebuilt per kind.
+     */
+    choice?: ICatalogChoice;
+    /**
+     * What this row refuses to be held with (ICatalogRestrictions), in the
+     * same one shape for every kind. Assembled from each source's own
+     * per-kind fields, so one enforcement pass covers all 69 rather than
+     * one hand-written gate covering one.
+     */
+    restrictions?: ICatalogRestrictions;
 }
 export interface ICatalogItem extends ICatalogBase {
     kind?: 'gear';
@@ -266,11 +222,41 @@ export interface ICatalogQuality extends ICatalogBase {
         requires?: 'awakened' | 'mundane' | 'caster-or-technomancer';
         requiresQuality?: string;
         requiresMetatype?: Metatype[];
+        /**
+         * THE FOUR FIELDS qualityRows() writes and this interface did not
+         * declare (found by maka-cli-com-c3 reading the commit, 2026-09-04).
+         *
+         * They were invisible to the compiler because the object literal
+         * carrying them contains conditional spreads, and a literal with a
+         * spread is no longer FRESH -- excess-property checking does not
+         * apply to it. So the row shipped four fields the published .d.ts
+         * denied existed, and the web's mirror would have needed a cast to
+         * read `row.quality.choice` -- the sort of cast that later gets
+         * tidied away by someone who trusts the type.
+         *
+         * DERIVED FROM IQuality, not retyped. `family`'s union and the shape
+         * of a choice live in qualities.ts, and indexing them here means the
+         * catalog cannot fall behind the source the way it just did. It also
+         * answers the question c3 asked -- "tell me if the names or the
+         * family union move" -- with "they cannot, if you index them too".
+         */
+        family: IQuality['family'];
+        inert?: string;
+        choice?: ICatalogChoice;
+        excludesQuality?: string;
     };
 }
 export interface ICatalogSpell extends ICatalogBase {
     kind: 'spell';
     spell: {
+        /**
+         * WHICH ROUTINE CASTS IT. The one field a row could not supply,
+         * and so the one thing stopping a spell from being sourced from
+         * the catalog rather than compiled in -- which is where the
+         * rules are headed (mjmcee, 2026-09-04: "the engine rule comes
+         * from the catalog. We shouldn't be hard coding the rules").
+         */
+        cast: 'combat' | 'heal' | 'armor' | 'sustained-utility' | 'barrier';
         category: 'Combat' | 'Detection' | 'Health' | 'Illusion' | 'Manipulation';
         type: 'mana' | 'physical';
         range: 'LOS' | 'LOS(A)' | 'touch';
@@ -296,6 +282,31 @@ export interface ICatalogAugmentation extends ICatalogBase {
         canonEssence?: number;
     };
 }
+/**
+ * AN ADEPT POWER (p.308-310). Bought with Power Points rather than nuyen
+ * or karma, which is why it carries no price: `levelCosts` is the PP to
+ * HOLD it at each level, and a magic-capped power extends linearly to the
+ * character's Magic.
+ */
+export interface ICatalogAdeptPower extends ICatalogBase {
+    kind: 'adept-power';
+    adeptPower: {
+        levelCosts: number[];
+        magicCapped: boolean;
+        costPerLevel?: number;
+    };
+}
+/**
+ * A METAMAGIC (p.325-326) or a technomancer's echo (p.258). Bought with an
+ * initiation or submersion grade, so it has no price either; `path` is who
+ * may take it.
+ */
+export interface ICatalogMetamagic extends ICatalogBase {
+    kind: 'metamagic';
+    metamagic: {
+        path: 'caster' | 'adept' | 'techno';
+    };
+}
 export interface ICatalogMetatype extends ICatalogBase {
     kind: 'metatype';
     metatype: {
@@ -307,11 +318,8 @@ export interface ICatalogMetatype extends ICatalogBase {
         lifestyleCostMult?: number;
     };
 }
-export type ICatalogRow = ICatalogItem | ICatalogQuality | ICatalogSpell | ICatalogAugmentation | ICatalogMetatype;
+export type ICatalogRow = ICatalogItem | ICatalogQuality | ICatalogSpell | ICatalogAugmentation | ICatalogMetatype | ICatalogAdeptPower | ICatalogMetamagic;
 /** Gear or not -- the discriminator every consumer of the gear list uses. */
 export declare function isGearRow(r: ICatalogRow): r is ICatalogItem;
 export declare const CATALOG_ITEMS: ICatalogItem[];
-/** THE WHOLE SEED, every kind. Gear today; qualities, spells, augmentations
- *  and metatypes join it in v14. The loader (utilities/catalog.ts) weighs
- *  THIS against the server and the cache. */
 export declare const CATALOG_ROWS: ICatalogRow[];

package/bundle/typescript/src/commands/game/sideQuest/utilities/catalog-data.js

@@ -20,7 +20,13 @@
  * gear -- these strings are what the player reads, and what an NPC's
  * swag briefing quotes.
  */
-export const CATALOG_VERSION = 13;
+import { AUGMENTATIONS } from '../augmentations.js';
+import { QUALITIES } from '../qualities.js';
+import { ADEPT_POWER_CATALOG } from '../adept-powers.js';
+import { SPELL_CATALOG } from '../spells.js';
+import { METATYPES } from '../metatypes.js';
+import { METAMAGICS } from '../commands/initiate.js';
+export const CATALOG_VERSION = 14;
 /** Gear or not -- the discriminator every consumer of the gear list uses. */
 export function isGearRow(r) {
     return r.kind === undefined || r.kind === 'gear';
@@ -279,11 +285,12 @@ export const CATALOG_ITEMS = [
     row('spirit-focus-1', 'Spirit Focus (Force 1)', 'Focus', 4000, 3, 'Where a summoner keeps the leash.', { page: 'p.461', shape: 'talisman', size: 'Tiny', weight: 0.1, rating: 'Standard', legality: 'R', stats: 'Force 1: force x 4,000 nuyen, avail (force x 3)R', ratingValue: 1, effects: [{ type: 'dice', category: 'skills', property: 'summoning', value: 1, when: 'carried', scaleBy: 'rating' }] }),
     row('weapon-focus-1', 'Weapon Focus (Force 1)', 'Focus', 7000, 4, 'A blade that cuts things that have never had a body.', { page: 'p.461', shape: 'blade', size: 'Medium', weight: 1.2, rating: 'Rare', legality: 'R', stats: 'Force 1: force x 7,000 nuyen, avail (force x 4)R', ratingValue: 1 }),
     row('power-focus-1', 'Power Focus (Force 1)', 'Focus', 18000, 4, 'A bound anchor for living mana. The real investment.', { page: 'p.461', shape: 'amulet', size: 'Tiny', weight: 0.2, rating: 'Rare', legality: 'R', stats: 'Force 1: force x 18,000 nuyen, avail (force x 4)R', ratingValue: 1, effects: [{ type: 'dice', category: 'skills', property: 'spellcasting', value: 1, when: 'carried', scaleBy: 'rating' }] }),
-    row('detection-spell-formula', 'Detection Spell Formula', 'SpellFormula', 500, 4, 'The notation for seeing what is not on offer. Bring talent.', { page: 'p.461', shape: 'scroll', size: 'Tiny', weight: 0.1, legality: 'R' }),
-    row('health-spell-formula', 'Health Spell Formula', 'SpellFormula', 500, 4, 'Mending, written down. Cheaper than a street doc, harder to learn.', { page: 'p.461', shape: 'scroll', size: 'Tiny', weight: 0.1, legality: 'R' }),
-    row('illusion-spell-formula', 'Illusion Spell Formula', 'SpellFormula', 1000, 8, 'How to lie to eyes, ears, and sensors at the same time.', { page: 'p.461', shape: 'scroll', size: 'Tiny', weight: 0.1, rating: 'Standard', legality: 'R' }),
-    row('manipulation-spell-formula', 'Manipulation Spell Formula', 'SpellFormula', 1500, 8, 'Moving the world with the mind, notated in someone else\'s hand.', { page: 'p.461', shape: 'scroll', size: 'Tiny', weight: 0.1, rating: 'Standard', legality: 'R' }),
-    row('combat-spell-formula', 'Combat Spell Formula', 'SpellFormula', 2000, 8, 'A combat spell, notated for study. Bring talent.', { page: 'p.461', shape: 'scroll', size: 'Tiny', weight: 0.1, rating: 'Standard', legality: 'R' }),
+    // SPELL FORMULAE ARE GENERATED, one per spell, by formulaRows() below
+    // -- a formula is written for ONE spell and priced by that spell's
+    // category (p.461). The five category-named rows that used to sit
+    // here could never teach anything: knowsSpell looks for the spell
+    // name inside the item name, and "Combat Spell Formula" contains no
+    // spell's name.
     // ---- Drones (p.466) ----
     // ANTHROPOMORPHIC DRONES (Rigger 5.0 p.145-148) -- the FIRST rows in
     // this catalog cited to a book other than the core rulebook, so the
@@ -393,8 +400,268 @@ export const CATALOG_ITEMS = [
     row('credstick-platinum', 'Certified Credstick (Platinum)', 'Credstick', 500, 10, 'Half a million, certified. People have died for the empty ones.', { page: 'p.443', shape: 'stick', size: 'Tiny', weight: 0.1, color: 'platinum', rating: 'Standard', stats: 'Max 500,000 nuyen' }),
     row('credstick-ebony', 'Certified Credstick (Ebony)', 'Credstick', 1000, 20, 'A million nuyen and a very short list of people who own one.', { page: 'p.443', shape: 'stick', size: 'Tiny', weight: 0.1, color: 'ebony', rating: 'Rare', stats: 'Max 1,000,000 nuyen' }),
 ];
-/** THE WHOLE SEED, every kind. Gear today; qualities, spells, augmentations
- *  and metatypes join it in v14. The loader (utilities/catalog.ts) weighs
- *  THIS against the server and the cache. */
-export const CATALOG_ROWS = CATALOG_ITEMS;
+/**
+ * THE NON-GEAR ROWS (catalog v14, user 2026-09-04: "I don't see any
+ * spells, or qualities there. The catalog should cover ALL things that
+ * can be obtained in the game, backed by canon").
+ *
+ * DERIVED, NEVER RETYPED. qualities.ts and augmentations.ts are the
+ * engine's own sources of truth -- the clinic charges from them, the
+ * creation ledger prices from them, the sheet prints from them -- so the
+ * catalog reads THOSE rather than carrying a second copy. A hand-copied
+ * list of something that already exists cannot stay right: that is
+ * exactly how the Conjurer shipped broken this morning, when a duplicate
+ * of MAGICAL_GROUP_SKILLS went stale the day the original moved.
+ *
+ * Every field here already existed on the source rows. Nothing is
+ * invented to fill the shape: `requiresMetatype` stays absent because
+ * this engine models no metatype and a gate it cannot check is a rule it
+ * cannot keep (qualities.ts says so in its own words), and `legality` /
+ * `canonEssence` stay absent on augmentations for the same reason --
+ * the source does not carry them.
+ */
+/**
+ * The restrictions a row declares, assembled from whichever per-kind
+ * fields its source happens to use. One shape out, so the server can
+ * enforce every kind in one pass; the sources keep the field names that
+ * read well where they live.
+ *
+ * Returns undefined rather than an empty object when a row restricts
+ * nothing, so "has restrictions" stays a truthiness check and 400 rows
+ * do not each grow an empty object.
+ */
+function restrictionsOf(src) {
+    const excludes = [
+        ...(src.excludes ?? []),
+        ...(src.excludesQuality !== undefined ? [src.excludesQuality] : []),
+    ];
+    const out = {
+        ...(excludes.length > 0 ? { excludes } : {}),
+        ...(src.requiresQuality !== undefined ? { needs: [src.requiresQuality] } : {}),
+        ...(src.requires !== undefined ? { path: src.requires } : {}),
+    };
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+function qualityRows() {
+    return QUALITIES.map(q => ({
+        kind: 'quality',
+        slug: q.key,
+        name: q.name,
+        description: q.effect,
+        page: q.page,
+        // The mechanics, in the same vocabulary a weapon states its DV in,
+        // so a reader of the catalog gets a quality's NUMBERS and not just
+        // its sentence. Absent where SR5's effect is not a flat modifier
+        // (or where the engine implements it as its own rule) -- see the
+        // `effects` comment in qualities.ts, which says why that is the
+        // honest answer rather than a gap to be filled in.
+        ...(q.effects !== undefined ? { effects: q.effects } : {}),
+        // On the ROW, not in the quality block -- ICatalogBase carries both,
+        // so chrome and spells declare them in the same place.
+        ...(q.choice !== undefined ? { choice: q.choice } : {}),
+        ...(restrictionsOf(q) !== undefined ? { restrictions: restrictionsOf(q) } : {}),
+        quality: {
+            polarity: q.kind,
+            karma: q.karma,
+            ...(q.maxRating !== undefined ? { maxRating: q.maxRating } : {}),
+            ...(q.retired !== undefined ? { retired: q.retired } : {}),
+            ...(q.requires !== undefined ? { requires: q.requires } : {}),
+            ...(q.requiresQuality !== undefined ? { requiresQuality: q.requiresQuality } : {}),
+            // WHAT KIND OF RULE this is, and whether the engine runs it yet.
+            // `family` is always present (qualities.ts requires it); `inert`
+            // is present only when the quality currently delivers nothing,
+            // and names the missing seat -- so a reader of the catalog can
+            // tell a finished rule from one that is still only priced.
+            family: q.family,
+            ...(q.inert !== undefined ? { inert: q.inert } : {}),
+            // The pick chargen has to collect before the quality can work,
+            // and the quality it may not be held alongside (p.65-66).
+            ...(q.excludesQuality !== undefined ? { excludesQuality: q.excludesQuality } : {}),
+        },
+    }));
+}
+function augmentationRows() {
+    return AUGMENTATIONS.map(a => ({
+        kind: 'augmentation',
+        slug: a.key,
+        name: a.name,
+        description: a.effect,
+        page: a.page,
+        // The dice, in the same vocabulary a weapon states its DV in. Chrome
+        // declared a `bonuses` map of its own until 2026-09-04, which is why
+        // this column read empty in the catalog while every piece of 'ware in
+        // the game was moving real dice.
+        ...(a.effects !== undefined ? { effects: a.effects } : {}),
+        // 62 of the 69 restrictions in the catalog are these: the exclusions
+        // that stop Wired Reflexes I riding alongside a synaptic booster, or
+        // three vision enhancements stacking. Declared for a long time,
+        // enforced by nothing.
+        ...(restrictionsOf(a) !== undefined ? { restrictions: restrictionsOf(a) } : {}),
+        augmentation: {
+            ware: a.kind,
+            essence: a.essence,
+            cost: a.cost,
+            wakeLine: a.wakeLine,
+            ...(a.excludes !== undefined ? { excludes: a.excludes } : {}),
+            ...(a.avail !== undefined ? { avail: a.avail } : {}),
+            ...(a.canonCost !== undefined ? { canonCost: a.canonCost } : {}),
+        },
+    }));
+}
+/** THE WHOLE SEED, every kind: gear, qualities and augmentations. Spells
+ *  and metatypes are still outstanding -- see the note above qualityRows.
+ *  The loader (utilities/catalog.ts) weighs THIS against the server and
+ *  the cache. */
+/**
+ * THE SPELLS (SR5 p.283-295). Held out of the catalog until now because
+ * ICatalogSpell wants Type, Range and Duration and the engine stored none
+ * of them -- recorded at the time as a deliberate omission rather than an
+ * oversight. spells.ts carries all three since 2026-09-04, each read off
+ * the printed stat block, so the shape is satisfied by canon rather than
+ * by inference and the rows can ship.
+ *
+ * A spell has no PRICE: it is learned, not bought, which is why the row
+ * carries no availability or nuyen and the spell block carries the drain
+ * instead. What a formula costs on the street is a GEAR row, and there
+ * are five of those already (Category 'SpellFormula').
+ */
+/**
+ * A spell's line, composed from its own stat block.
+ *
+ * spells.ts carries no prose -- it never needed any, because cast.ts
+ * names the spell and rolls it -- and inventing twenty-one descriptions
+ * to fill a `description` field would be putting words in the book's
+ * mouth. So the line is DERIVED: the printed Type, Range, Duration and
+ * Drain, in a sentence, plus what resists it. Every word of it is data
+ * the row already carries.
+ */
+function spellLine(sp) {
+    const range = sp.range === 'touch' ? 'Touch' : sp.range === 'LOS(A)' ? 'line of sight, area' : 'line of sight';
+    const duration = sp.duration === 'I' ? 'instantaneous' : sp.duration === 'S' ? 'sustained' : 'permanent';
+    const drain = `Drain F${sp.drainOffset === 0 ? '' : sp.drainOffset > 0 ? ` + ${sp.drainOffset}` : ` - ${-sp.drainOffset}`}`;
+    const resist = sp.soak === 'willpower' ? '; resisted with Willpower'
+        : sp.soak === 'body' ? '; resisted with Body'
+            : sp.soak === 'armor' ? '; soaked in full, less AP' : '';
+    return `${sp.category} spell, ${sp.type}, ${range}, ${duration}. ${drain}${resist}.`;
+}
+/**
+ * WHAT A FORMULA COSTS, by the category of the spell it teaches (p.461,
+ * priced from the Magical Goods table). The formula is for ONE spell;
+ * the CATEGORY is only what sets the price, which is why these rows are
+ * generated per spell rather than per category.
+ */
+const FORMULA_PRICE = {
+    Detection: { price: 500, avail: 4 },
+    Health: { price: 500, avail: 4 },
+    Illusion: { price: 1000, avail: 8 },
+    Manipulation: { price: 1500, avail: 8 },
+    Combat: { price: 2000, avail: 8 },
+};
+/**
+ * ONE FORMULA PER SPELL, derived from SPELL_CATALOG.
+ *
+ * These are GEAR rows -- a scroll you buy from a talismonger and carry --
+ * and they are the first gear the engine reads for something other than
+ * a dice modifier: `teaches` names the spell, and Player.knowsSpell reads
+ * it. Generated rather than authored so a spell added tomorrow is
+ * purchasable the same day, with no second edit to forget.
+ *
+ * The Detection price sits in the table above and produces no rows,
+ * because this engine has no Detection spell yet. That is deliberate: a
+ * "Detection Spell Formula" WAS on sale here for 500 nuyen, for a
+ * category with nothing in it.
+ */
+function formulaRows() {
+    return SPELL_CATALOG.map(sp => {
+        const { price, avail } = FORMULA_PRICE[sp.category];
+        return row(`spell-formula-${sp.key}`, `Spell Formula (${sp.name})`, 'SpellFormula', price, avail, `${sp.name}, notated for study in somebody else's hand. Bring talent.`, {
+            page: 'p.461', shape: 'scroll', size: 'Tiny', weight: 0.1, legality: 'R',
+            teaches: sp.key,
+            stats: `${sp.category} formula: ${price} nuyen, avail ${avail}R`,
+        });
+    });
+}
+function spellRows() {
+    return SPELL_CATALOG.map(sp => ({
+        kind: 'spell',
+        slug: sp.key,
+        name: sp.name,
+        description: spellLine(sp),
+        page: sp.page,
+        // What it does to whoever it is held on, in the shared vocabulary.
+        // Absent on every Instantaneous spell -- a combat spell resolves at
+        // cast time -- and on the two barriers, whose effect is a wall in a
+        // room rather than a modifier on anybody.
+        ...(sp.effects !== undefined ? { effects: sp.effects } : {}),
+        spell: {
+            cast: sp.cast,
+            category: sp.category,
+            type: sp.type,
+            range: sp.range,
+            duration: sp.duration,
+            drainOffset: sp.drainOffset,
+            ...(sp.soak !== undefined ? { soak: sp.soak } : {}),
+            ...(sp.stun !== undefined ? { stun: sp.stun } : {}),
+            ...(sp.area !== undefined ? { area: sp.area } : {}),
+            ...(sp.touch !== undefined ? { touch: sp.touch } : {}),
+        },
+    }));
+}
+function adeptPowerRows() {
+    return ADEPT_POWER_CATALOG.map(a => ({
+        kind: 'adept-power',
+        slug: a.key,
+        name: a.name,
+        description: a.effect,
+        page: a.page,
+        ...(a.effects !== undefined ? { effects: a.effects } : {}),
+        adeptPower: {
+            levelCosts: a.levelCosts,
+            magicCapped: a.magicCapped,
+            ...(a.costPerLevel !== undefined ? { costPerLevel: a.costPerLevel } : {}),
+        },
+    }));
+}
+function metamagicRows() {
+    return METAMAGICS.map(m => ({
+        kind: 'metamagic',
+        slug: m.key,
+        name: m.name,
+        description: m.effect,
+        page: m.page,
+        ...(m.effects !== undefined ? { effects: m.effects } : {}),
+        metamagic: { path: m.path },
+    }));
+}
+/**
+ * THE METATYPES (p.66). Rows only: this engine models no metatype on a
+ * character and this pass does not change that -- what it does is put the
+ * table where it can be read, cited and priced, so the shape stops being
+ * an empty promise in the schema.
+ */
+function metatypeRows() {
+    return METATYPES.map(m => ({
+        kind: 'metatype',
+        slug: m.key,
+        name: m.name,
+        description: m.description,
+        page: m.page,
+        ...(m.effects !== undefined ? { effects: m.effects } : {}),
+        metatype: {
+            attributes: m.attributes,
+            sprintMetersPerHit: m.sprintMetersPerHit,
+            ...(m.lifestyleCostMult !== undefined ? { lifestyleCostMult: m.lifestyleCostMult } : {}),
+        },
+    }));
+}
+export const CATALOG_ROWS = [
+    ...CATALOG_ITEMS,
+    ...formulaRows(),
+    ...qualityRows(),
+    ...augmentationRows(),
+    ...adeptPowerRows(),
+    ...metamagicRows(),
+    ...spellRows(),
+    ...metatypeRows(),
+];
 //# sourceMappingURL=catalog-data.js.map