hpp-lang 0.6.0

package/dist/examples.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"examples.js","sourceRoot":"","sources":["../src/examples.ts"],"names":[],"mappings":"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"}

package/dist/extensions/line/index.d.ts

@@ -0,0 +1,45 @@
+import { ExtensionDescriptor } from '../../capabilities.js';
+import { Hardware, SensorValue } from '../../hardware.js';
+/**
+ * Extensão Line (§11, mínima): contratos para seguidores de linha.
+ * Seguidor de linha é H++ com outro vocabulário — mesma gramática,
+ * mesmo interpretador, sem nenhum outro domínio em nenhum import daqui.
+ */
+export declare const LINE_EXT_VERSION = "0.2.0";
+export declare const LINE_EXTENSION: ExtensionDescriptor;
+/** Leitura de N sensores de refletância (0 = branco, 1 = preto). */
+export interface LineArrayReading {
+    values: number[];
+}
+/** Sensor de linha genérico: funciona no simulador, ESP32, RP2040... */
+export interface LineSensor {
+    read(): LineArrayReading;
+}
+/** Erro lateral da linha (-1..1): 0 = centrado. Base do PID de linha. */
+export declare function lineError(reading: LineArrayReading): number;
+/** Controlador de linha (P/PD): exemplo de uso no adapter, não no núcleo. */
+export interface LineController {
+    update(error: number, deltaTime: number): {
+        throttle: number;
+        steer: number;
+    };
+}
+/**
+ * Hardware de mentira para seguidores de linha (testes e sala de aula):
+ * implementa só o subconjunto que o domínio Line precisa.
+ */
+export declare class MockLineHardware implements Hardware {
+    readonly log: string[];
+    /** Sensores injetados pelo teste (esq, centro, dir). */
+    lineValues: number[];
+    sensors(): Record<string, SensorValue>;
+    drive(throttle: number): void;
+    turn(steer: number): void;
+    fire(): void;
+    stop(): void;
+    aimMain(): void;
+    aimSecondary(): void;
+    radioSend(msg: number): void;
+    dribble(on: boolean): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/line/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/line/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE1D;;;;GAIG;AAEH,eAAO,MAAM,gBAAgB,UAAU,CAAC;AAExC,eAAO,MAAM,cAAc,EAAE,mBAoB5B,CAAC;AAEF,oEAAoE;AACpE,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,wEAAwE;AACxE,MAAM,WAAW,UAAU;IACzB,IAAI,IAAI,gBAAgB,CAAC;CAC1B;AAED,yEAAyE;AACzE,wBAAgB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAW3D;AAED,6EAA6E;AAC7E,MAAM,WAAW,cAAc;IAC7B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAC/E;AAED;;;GAGG;AACH,qBAAa,gBAAiB,YAAW,QAAQ;IAC/C,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,CAAM;IAC5B,wDAAwD;IACxD,UAAU,EAAE,MAAM,EAAE,CAAa;IAEjC,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC;IAatC,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAI7B,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIzB,IAAI,IAAI,IAAI;IAIZ,IAAI,IAAI,IAAI;IAIZ,OAAO,IAAI,IAAI;IAIf,YAAY,IAAI,IAAI;IAIpB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAI5B,OAAO,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI;CAG3B"}

package/dist/extensions/line/index.js

@@ -0,0 +1,99 @@
+/**
+ * Extensão Line (§11, mínima): contratos para seguidores de linha.
+ * Seguidor de linha é H++ com outro vocabulário — mesma gramática,
+ * mesmo interpretador, sem nenhum outro domínio em nenhum import daqui.
+ */
+export const LINE_EXT_VERSION = '0.2.0';
+export const LINE_EXTENSION = {
+    id: 'line',
+    version: LINE_EXT_VERSION,
+    domain: 'Line Following',
+    /** §17: `line_sensor` + `motor` + `encoder`. Sem nenhum outro domínio daqui. */
+    capabilities: ['motor', 'encoder', 'line_sensor'],
+    sensors: [
+        'linha_esq', 'line_left',
+        'linha_centro', 'line_center',
+        'linha_dir', 'line_right',
+        'erro_linha', 'line_error',
+        'encoder', 'odometria', 'odometry',
+        'ciclo', 'cycle'
+    ],
+    actions: ['drive', 'turn', 'stop'],
+    sensorRequires: {
+        encoder: ['encoder'],
+        odometria: ['odometry'],
+        odometry: ['odometry']
+    }
+};
+/** Erro lateral da linha (-1..1): 0 = centrado. Base do PID de linha. */
+export function lineError(reading) {
+    const n = reading.values.length;
+    if (n === 0)
+        return 0;
+    let num = 0;
+    let den = 0;
+    for (let i = 0; i < n; i++) {
+        const w = (i / (n - 1)) * 2 - 1; // -1 (esq) .. +1 (dir)
+        num += w * reading.values[i];
+        den += reading.values[i];
+    }
+    return den === 0 ? 0 : num / den;
+}
+/**
+ * Hardware de mentira para seguidores de linha (testes e sala de aula):
+ * implementa só o subconjunto que o domínio Line precisa.
+ */
+export class MockLineHardware {
+    constructor() {
+        Object.defineProperty(this, "log", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        /** Sensores injetados pelo teste (esq, centro, dir). */
+        Object.defineProperty(this, "lineValues", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [0, 0, 0]
+        });
+    }
+    sensors() {
+        return {
+            linha_esq: this.lineValues[0] ?? 0,
+            line_left: this.lineValues[0] ?? 0,
+            linha_centro: this.lineValues[1] ?? 0,
+            line_center: this.lineValues[1] ?? 0,
+            linha_dir: this.lineValues[2] ?? 0,
+            line_right: this.lineValues[2] ?? 0,
+            erro_linha: lineError({ values: this.lineValues }),
+            line_error: lineError({ values: this.lineValues })
+        };
+    }
+    drive(throttle) {
+        this.log.push(`drive:${throttle}`);
+    }
+    turn(steer) {
+        this.log.push(`turn:${steer}`);
+    }
+    fire() {
+        this.log.push('fire');
+    }
+    stop() {
+        this.log.push('stop');
+    }
+    aimMain() {
+        this.log.push('aimMain');
+    }
+    aimSecondary() {
+        this.log.push('aimSecondary');
+    }
+    radioSend(msg) {
+        this.log.push(`radio:${msg}`);
+    }
+    dribble(on) {
+        this.log.push(`dribble:${on}`);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/extensions/line/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/extensions/line/index.ts"],"names":[],"mappings":"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"}

package/dist/extensions/maze/index.d.ts

@@ -0,0 +1,37 @@
+import { ExtensionDescriptor } from '../../capabilities.js';
+/**
+ * Extensão Maze (§12, SÓ CONTRATOS): nenhuma lógica aqui de propósito
+ * (§9: não implementar futuro desnecessariamente). Quando existir um
+ * simulador/hardware de labirinto, ele implementa estas interfaces e
+ * declara `MAZE_EXTENSION` — o núcleo H++ não muda.
+ *
+ * NOTA DE DOUTRINA: `celula_x/cell_z` (posição discreta) abrem exceção
+ * deliberada à percepção relativa — mapear labirinto exige saber onde se
+ * está na grade. É a única exceção prevista; todo o resto é relativo.
+ */
+export declare const MAZE_EXT_VERSION = "0.2.0";
+export declare const MAZE_EXTENSION: ExtensionDescriptor;
+/** Distância em metros numa direção. */
+export interface DistanceSensor {
+    read(): number;
+}
+/** Detector de parede (porta lógica sobre distância + limiar). */
+export interface WallDetector {
+    wallAhead(): boolean;
+    wallLeft(): boolean;
+    wallRight(): boolean;
+}
+/** Posição discreta no labirinto (para mapa/grafo futuro). */
+export interface GridCell {
+    x: number;
+    z: number;
+}
+/** Mapa mínimo: diz se a célula é livre. */
+export interface MazeMap {
+    isFree(cell: GridCell): boolean;
+}
+/** Navegador futuro (exploração/caminho virão depois, §9). */
+export interface Navigator {
+    nextWaypoint(from: GridCell): GridCell | null;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/maze/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/maze/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;;;;;;;;GASG;AAEH,eAAO,MAAM,gBAAgB,UAAU,CAAC;AAExC,eAAO,MAAM,cAAc,EAAE,mBA8B5B,CAAC;AAEF,wCAAwC;AACxC,MAAM,WAAW,cAAc;IAC7B,IAAI,IAAI,MAAM,CAAC;CAChB;AAED,kEAAkE;AAClE,MAAM,WAAW,YAAY;IAC3B,SAAS,IAAI,OAAO,CAAC;IACrB,QAAQ,IAAI,OAAO,CAAC;IACpB,SAAS,IAAI,OAAO,CAAC;CACtB;AAED,8DAA8D;AAC9D,MAAM,WAAW,QAAQ;IACvB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,4CAA4C;AAC5C,MAAM,WAAW,OAAO;IACtB,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC;CACjC;AAED,8DAA8D;AAC9D,MAAM,WAAW,SAAS;IACxB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,IAAI,CAAC;CAC/C"}

package/dist/extensions/maze/index.js

@@ -0,0 +1,43 @@
+/**
+ * Extensão Maze (§12, SÓ CONTRATOS): nenhuma lógica aqui de propósito
+ * (§9: não implementar futuro desnecessariamente). Quando existir um
+ * simulador/hardware de labirinto, ele implementa estas interfaces e
+ * declara `MAZE_EXTENSION` — o núcleo H++ não muda.
+ *
+ * NOTA DE DOUTRINA: `celula_x/cell_z` (posição discreta) abrem exceção
+ * deliberada à percepção relativa — mapear labirinto exige saber onde se
+ * está na grade. É a única exceção prevista; todo o resto é relativo.
+ */
+export const MAZE_EXT_VERSION = '0.2.0';
+export const MAZE_EXTENSION = {
+    id: 'maze',
+    version: MAZE_EXT_VERSION,
+    domain: 'Maze / Labyrinth',
+    /** §18/§33: distância, parede, bússola e encoder — sem depender de nenhum outro domínio. */
+    capabilities: ['motor', 'encoder', 'distance_sensor', 'wall_detector', 'compass'],
+    sensors: [
+        'dist_frente', 'dist_ahead',
+        'dist_esq', 'dist_left',
+        'dist_dir', 'dist_right',
+        'parede_frente', 'wall_ahead',
+        'parede_esquerda', 'wall_left',
+        'parede_direita', 'wall_right',
+        'bussola', 'compass',
+        'encoder', 'odometria', 'odometry',
+        'celula_x', 'cell_x',
+        'celula_z', 'cell_z'
+    ],
+    actions: ['drive', 'turn', 'stop'],
+    sensorRequires: {
+        parede_frente: ['wall_detector'],
+        wall_ahead: ['wall_detector'],
+        parede_esquerda: ['wall_detector'],
+        wall_left: ['wall_detector'],
+        parede_direita: ['wall_detector'],
+        wall_right: ['wall_detector'],
+        encoder: ['encoder'],
+        odometria: ['odometry'],
+        odometry: ['odometry']
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/extensions/maze/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/extensions/maze/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AAEH,MAAM,CAAC,MAAM,gBAAgB,GAAG,OAAO,CAAC;AAExC,MAAM,CAAC,MAAM,cAAc,GAAwB;IACjD,EAAE,EAAE,MAAM;IACV,OAAO,EAAE,gBAAgB;IACzB,MAAM,EAAE,kBAAkB;IAC1B,4FAA4F;IAC5F,YAAY,EAAE,CAAC,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,eAAe,EAAE,SAAS,CAAC;IACjF,OAAO,EAAE;QACP,aAAa,EAAE,YAAY;QAC3B,UAAU,EAAE,WAAW;QACvB,UAAU,EAAE,YAAY;QACxB,eAAe,EAAE,YAAY;QAC7B,iBAAiB,EAAE,WAAW;QAC9B,gBAAgB,EAAE,YAAY;QAC9B,SAAS,EAAE,SAAS;QACpB,SAAS,EAAE,WAAW,EAAE,UAAU;QAClC,UAAU,EAAE,QAAQ;QACpB,UAAU,EAAE,QAAQ;KACrB;IACD,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC;IAClC,cAAc,EAAE;QACd,aAAa,EAAE,CAAC,eAAe,CAAC;QAChC,UAAU,EAAE,CAAC,eAAe,CAAC;QAC7B,eAAe,EAAE,CAAC,eAAe,CAAC;QAClC,SAAS,EAAE,CAAC,eAAe,CAAC;QAC5B,cAAc,EAAE,CAAC,eAAe,CAAC;QACjC,UAAU,EAAE,CAAC,eAAe,CAAC;QAC7B,OAAO,EAAE,CAAC,SAAS,CAAC;QACpB,SAAS,EAAE,CAAC,UAAU,CAAC;QACvB,QAAQ,EAAE,CAAC,UAAU,CAAC;KACvB;CACF,CAAC"}

package/dist/extensions/soccer/index.d.ts

@@ -0,0 +1,8 @@
+import { ExtensionDescriptor } from '../../capabilities.js';
+/**
+ * Extensão Soccer (primeiro domínio, §10): descreve o vocabulário soccer
+ * sem tocar no parser — sensores chegam por snapshot, ações pelo `Hardware`.
+ */
+export declare const SOCCER_EXT_VERSION = "0.4.0";
+export declare const SOCCER_EXTENSION: ExtensionDescriptor;
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/soccer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/soccer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;;GAGG;AACH,eAAO,MAAM,kBAAkB,UAAU,CAAC;AAE1C,eAAO,MAAM,gBAAgB,EAAE,mBAsF9B,CAAC"}

package/dist/extensions/soccer/index.js

@@ -0,0 +1,93 @@
+/**
+ * Extensão Soccer (primeiro domínio, §10): descreve o vocabulário soccer
+ * sem tocar no parser — sensores chegam por snapshot, ações pelo `Hardware`.
+ */
+export const SOCCER_EXT_VERSION = '0.4.0';
+export const SOCCER_EXTENSION = {
+    id: 'soccer',
+    version: SOCCER_EXT_VERSION,
+    domain: 'Soccer Infrared',
+    /**
+     * Soccer declara o drivetrain diferencial do simulador (`MOTORES`) e
+     * odometria por encoder (§15/§18). NÃO declara `motor_individual`/
+     * `motor_left`/`motor_right`: o modelo simulado não tem rodas independentes
+     * reais — `MOTOR_ESQUERDO` é barrado de propósito (§10/§32).
+     */
+    capabilities: [
+        'motor', 'differential_drive', 'encoder',
+        'compass', 'distance_sensor', 'ball_sensor',
+        'radio', 'kicker', 'dribbler', 'line_sensor'
+    ],
+    sensors: [
+        'ver_bola', 'see_ball',
+        'direcao_bola', 'ball_dir',
+        'direcao_gol', 'goal_dir',
+        'dist_bola', 'ball_dist',
+        'forca_sinal', 'signal',
+        'setor_bola', 'ball_sector',
+        'bussola', 'compass',
+        'deriva_bussola', 'compass_drift',
+        'dist_frente', 'dist_ahead',
+        'tof_esq', 'tof_left',
+        'tof_dir', 'tof_right',
+        'linha_frente', 'line_front',
+        'linha_tras', 'line_back',
+        'linha_esq', 'line_left',
+        'linha_dir', 'line_right',
+        'encoder', 'odometria', 'odometry',
+        'velocidade', 'speed',
+        'velocidade_angular', 'angular_speed',
+        'tempo', 'time',
+        'tempo_total', 'total_time',
+        'placar_eu', 'my_score',
+        'placar_outro', 'foe_score',
+        'fase', 'phase',
+        'radio'
+    ],
+    actions: ['drive', 'turn', 'kick', 'stop', 'aimBall', 'aimGoal', 'radioSend', 'dribble'],
+    /** Verificação por ação (§9): o resto (locomoção/mira de gol) não exige nada além do robô. */
+    requires: {
+        kick: ['kicker'],
+        dribble: ['dribbler'],
+        radioSend: ['radio'],
+        aimBall: ['ball_sensor']
+    },
+    /**
+     * Verificação por sensor: `direcao_gol` é geometria (sem exigência);
+     * resto do jogo (tempo/placar/fase/radio) não exige capacidade.
+     */
+    sensorRequires: {
+        ver_bola: ['ball_sensor'],
+        see_ball: ['ball_sensor'],
+        direcao_bola: ['ball_sensor'],
+        ball_dir: ['ball_sensor'],
+        dist_bola: ['ball_sensor'],
+        ball_dist: ['ball_sensor'],
+        forca_sinal: ['ball_sensor'],
+        signal: ['ball_sensor'],
+        setor_bola: ['ball_sensor'],
+        ball_sector: ['ball_sensor'],
+        bussola: ['compass'],
+        compass: ['compass'],
+        deriva_bussola: ['compass'],
+        compass_drift: ['compass'],
+        dist_frente: ['distance_sensor'],
+        dist_ahead: ['distance_sensor'],
+        tof_esq: ['distance_sensor'],
+        tof_left: ['distance_sensor'],
+        tof_dir: ['distance_sensor'],
+        tof_right: ['distance_sensor'],
+        linha_frente: ['line_sensor'],
+        line_front: ['line_sensor'],
+        linha_tras: ['line_sensor'],
+        line_back: ['line_sensor'],
+        linha_esq: ['line_sensor'],
+        line_left: ['line_sensor'],
+        linha_dir: ['line_sensor'],
+        line_right: ['line_sensor'],
+        encoder: ['encoder'],
+        odometria: ['odometry'],
+        odometry: ['odometry']
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/extensions/soccer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/extensions/soccer/index.ts"],"names":[],"mappings":"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"}

package/dist/hardware.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Contrato de hardware do H++: o núcleo da linguagem só enxerga SENSORES
+ * (leitura, foto tirada a cada ciclo) e AÇÕES (atuadores). Qualquer projeto —
+ * futebol, seguidor de linha, robô físico — implementa esta interface
+ * (ver `adapters/` no futuro; hoje o simulador injeta o adapter soccer).
+ */
+export type SensorValue = number | boolean | string;
+export interface Hardware {
+    /** Foto nova dos sensores a cada ciclo (tick). */
+    sensors(): Record<string, SensorValue>;
+    /**
+     * Relógio: o núcleo fornece `ciclo` (determinístico); tempo de parede/jogo
+     * (`tempo`) é responsabilidade do domínio via snapshot, se fizer sentido.
+     */
+    /** Avanço (-1..1). Valores fora da faixa são aparados. */
+    drive(throttle: number): void;
+    /** Giro (-1..1). Valores fora da faixa são aparados. */
+    turn(steer: number): void;
+    /** Dispara o atuador principal (chute/garra/luz — depende do hardware). */
+    fire(): void;
+    /** Para tudo. */
+    stop(): void;
+    /** Mira sozinho o alvo principal (bola/linha) com controle P. */
+    aimMain(): void;
+    /** Mira sozinho o alvo secundário (gol/base). */
+    aimSecondary(): void;
+    /** Envia um número no rádio da equipe. */
+    radioSend(msg: number): void;
+    /** Liga/desliga o rolete de drible (gruda a bola na frente). */
+    dribble(on: boolean): void;
+    /** `MOTOR id, velocidade` — capability `motor_individual`. */
+    motor?(id: number, value: number): void;
+    /** `MOTOR_ESQUERDO v` — capability `motor_left`. */
+    motorLeft?(value: number): void;
+    /** `MOTOR_DIREITO v` — capability `motor_right`. */
+    motorRight?(value: number): void;
+    /** `MOTORES esquerda, direita` — capability `differential_drive`. */
+    motors?(left: number, right: number): void;
+    /** `MOVER_LATERAL v` — capability `holonomic_drive`. */
+    moveLateral?(value: number): void;
+    /** `MOVER_XY vx, vy` — capability `holonomic_drive`. */
+    moveXY?(vx: number, vy: number): void;
+}
+//# sourceMappingURL=hardware.d.ts.map

package/dist/hardware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hardware.d.ts","sourceRoot":"","sources":["../src/hardware.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAEpD,MAAM,WAAW,QAAQ;IACvB,kDAAkD;IAClD,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACvC;;;OAGG;IACH,0DAA0D;IAC1D,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,wDAAwD;IACxD,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,2EAA2E;IAC3E,IAAI,IAAI,IAAI,CAAC;IACb,iBAAiB;IACjB,IAAI,IAAI,IAAI,CAAC;IACb,iEAAiE;IACjE,OAAO,IAAI,IAAI,CAAC;IAChB,iDAAiD;IACjD,YAAY,IAAI,IAAI,CAAC;IACrB,0CAA0C;IAC1C,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,gEAAgE;IAChE,OAAO,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAAC;IAO3B,8DAA8D;IAC9D,KAAK,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,oDAAoD;IACpD,SAAS,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,oDAAoD;IACpD,UAAU,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,qEAAqE;IACrE,MAAM,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,wDAAwD;IACxD,WAAW,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,wDAAwD;IACxD,MAAM,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;CACvC"}

package/dist/hardware.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hardware.js.map

package/dist/hardware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hardware.js","sourceRoot":"","sources":["../src/hardware.ts"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+import { type LexOptions } from './lexer.js';
+import { RunOptions, RunResult } from './interpreter.js';
+import type { HppError } from './errors.js';
+import { Hardware } from './hardware.js';
+import { Stmt } from './ast.js';
+export { lex as Lexer, lex } from './lexer.js';
+export { Parser } from './parser.js';
+export { Interpreter } from './interpreter.js';
+export type { Expr, Stmt } from './ast.js';
+export type { Token, TokenType } from './tokens.js';
+export type { HppError } from './errors.js';
+export { RuntimeError } from './errors.js';
+export type { HppError as InterpreterHppError } from './interpreter.js';
+export type { Hardware, SensorValue } from './hardware.js';
+export { HppRuntime } from './runtime.js';
+export { HPP_CORE_VERSION } from './version.js';
+export type { VersionInfo } from './version.js';
+export type { Capability, ExtensionDescriptor } from './capabilities.js';
+export { checkRequirements, missingCapabilitiesMessage, checkProgramActions, collectProgramActions, collectProgramSensors } from './capabilities.js';
+export type { ActionSpec, ActionName } from './tokens.js';
+export { stripAccents, type LexOptions } from './lexer.js';
+export type { LexError } from './lexer.js';
+export type { ParseError } from './parser.js';
+export type { SensorSnapshot } from './robotics/sensors.js';
+export { normalizeSnapshotKeys } from './robotics/snapshot.js';
+export { CANONICAL_ACTIONS, type CanonicalAction } from './robotics/actions.js';
+export type { Value, HppFunction, Builtin } from './robotics/types.js';
+/** Robotics Motion Primitives (§5–§14): contrato, ações e relógio do movimento. */
+export { HPP_ROBOTICS_VERSION, MOTION_ACTIONS, MOTION_STATE_SENSORS, isMotionAction, missingMotionCapability, motionCapabilityError } from './robotics/index.js';
+export type { MotionAction, MotionCommand, MotionCapabilities, MotorCapabilities, EncoderCapabilities, LocomotionCapabilities, RoboticsProfile } from './robotics/index.js';
+export type { RunOptions, RunResult } from './interpreter.js';
+export { SOCCER_EXTENSION, SOCCER_EXT_VERSION } from './extensions/soccer/index.js';
+export { LINE_EXTENSION, LINE_EXT_VERSION, lineError, MockLineHardware } from './extensions/line/index.js';
+export type { LineArrayReading, LineSensor, LineController } from './extensions/line/index.js';
+export { MAZE_EXTENSION, MAZE_EXT_VERSION } from './extensions/maze/index.js';
+export type { DistanceSensor, WallDetector, GridCell, MazeMap, Navigator } from './extensions/maze/index.js';
+/** Programa compilado: rode `run(hardware)` uma vez por ciclo. */
+export declare class Program {
+    readonly statements: Stmt[];
+    private interp;
+    constructor(statements: Stmt[]);
+    /**
+     * Executa 1 ciclo. Variáveis do aluno sobrevivem entre chamadas.
+     * `opts` (§7/§28): capabilities para checagem em runtime + `dt` do relógio
+     * determinístico; sem `opts`, o núcleo roda "puro" (sem gate de capability).
+     */
+    run(hw: Hardware, fuel?: number, opts?: RunOptions): RunResult;
+    /** Apaga a memória do aluno (recomeçar do zero). */
+    reset(): void;
+}
+export interface CompileResult {
+    program: Program | null;
+    errors: HppError[];
+}
+/** Compila fonte H++ (PT/EN). Erros vêm com linha e dica em português. */
+export declare function compile(source: string, opts?: {
+    extraActions?: LexOptions['extraActions'];
+}): CompileResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,69 @@
+import { lex } from './lexer.js';
+import { Parser } from './parser.js';
+import { Interpreter } from './interpreter.js';
+// Pipeline da linguagem (núcleo puro): Lexer → Parser → AST → Interpreter.
+export { lex as Lexer, lex } from './lexer.js';
+export { Parser } from './parser.js';
+export { Interpreter } from './interpreter.js';
+export { RuntimeError } from './errors.js';
+export { HppRuntime } from './runtime.js';
+export { HPP_CORE_VERSION } from './version.js';
+export { checkRequirements, missingCapabilitiesMessage, checkProgramActions, collectProgramActions, collectProgramSensors } from './capabilities.js';
+export { stripAccents } from './lexer.js';
+export { normalizeSnapshotKeys } from './robotics/snapshot.js';
+export { CANONICAL_ACTIONS } from './robotics/actions.js';
+/** Robotics Motion Primitives (§5–§14): contrato, ações e relógio do movimento. */
+export { HPP_ROBOTICS_VERSION, MOTION_ACTIONS, MOTION_STATE_SENSORS, isMotionAction, missingMotionCapability, motionCapabilityError } from './robotics/index.js';
+// Extensões de domínio (soccer / line / maze).
+export { SOCCER_EXTENSION, SOCCER_EXT_VERSION } from './extensions/soccer/index.js';
+export { LINE_EXTENSION, LINE_EXT_VERSION, lineError, MockLineHardware } from './extensions/line/index.js';
+export { MAZE_EXTENSION, MAZE_EXT_VERSION } from './extensions/maze/index.js';
+/** Programa compilado: rode `run(hardware)` uma vez por ciclo. */
+export class Program {
+    constructor(statements) {
+        Object.defineProperty(this, "statements", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: statements
+        });
+        Object.defineProperty(this, "interp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Interpreter()
+        });
+    }
+    /**
+     * Executa 1 ciclo. Variáveis do aluno sobrevivem entre chamadas.
+     * `opts` (§7/§28): capabilities para checagem em runtime + `dt` do relógio
+     * determinístico; sem `opts`, o núcleo roda "puro" (sem gate de capability).
+     */
+    run(hw, fuel = 5000, opts) {
+        return this.interp.run(this.statements, hw, fuel, opts);
+    }
+    /** Apaga a memória do aluno (recomeçar do zero). */
+    reset() {
+        this.interp.reset();
+    }
+}
+/** Compila fonte H++ (PT/EN). Erros vêm com linha e dica em português. */
+export function compile(source, opts) {
+    const { tokens, errors: lexErrors } = lex(source, opts ?? {});
+    const errors = lexErrors.map((e) => ({ line: e.line, col: e.col, message: e.message }));
+    if (errors.length > 0)
+        return { program: null, errors };
+    const parser = new Parser(tokens);
+    const statements = parser.parse();
+    for (const e of parser.errors) {
+        errors.push({ line: e.line, col: e.col, message: e.message });
+    }
+    if (errors.length > 0 || statements.length === 0) {
+        if (statements.length === 0 && errors.length === 0) {
+            return { program: new Program([]), errors: [] };
+        }
+        return { program: null, errors };
+    }
+    return { program: new Program(statements), errors: [] };
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}