okengine 0.1.4

package/src/compiler/http-parse.ts

@@ -0,0 +1,214 @@
+/**
+ * Shared HTTP request parsing and input assembly for AoT and dynamic paths.
+ *
+ * Both compilers must call these helpers so responses stay byte-identical.
+ */
+
+/** Which request parts a route handler needs. */
+export interface ContextInference {
+  readonly body: boolean;
+  readonly query: boolean;
+  readonly params: boolean;
+  readonly headers: boolean;
+  readonly cookie: boolean;
+}
+
+/** Mutable inference accumulator (sucrose merges with OR). */
+export type MutableInference = {
+  -readonly [K in keyof ContextInference]: boolean;
+};
+
+/** Parts extracted from a request before contract validation. */
+export interface InputParts {
+  readonly params?: Readonly<Record<string, string>>;
+  readonly query?: Readonly<Record<string, string>>;
+  readonly headers?: Readonly<Record<string, string>>;
+  readonly cookie?: Readonly<Record<string, string>>;
+  readonly body?: unknown;
+}
+
+/** All context slots enabled — used by the dynamic fallback. */
+export const FULL_INFERENCE: ContextInference = {
+  body: true,
+  query: true,
+  params: true,
+  headers: true,
+  cookie: true,
+};
+
+/** Empty inference seed. */
+export function emptyInference(): MutableInference {
+  return {
+    body: false,
+    query: false,
+    params: false,
+    headers: false,
+    cookie: false,
+  };
+}
+
+/**
+ * Merge inference flags with logical OR.
+ *
+ * @param into - Accumulator
+ * @param next - Flags to merge
+ */
+export function mergeInference(
+  into: MutableInference,
+  next: ContextInference,
+): MutableInference {
+  into.body = into.body || next.body;
+  into.query = into.query || next.query;
+  into.params = into.params || next.params;
+  into.headers = into.headers || next.headers;
+  into.cookie = into.cookie || next.cookie;
+  return into;
+}
+
+/**
+ * Extract `:param` names from an HTTP path pattern.
+ *
+ * @param path - Route path (e.g. `/notes/:id`)
+ */
+export function pathParamNames(path: string): string[] {
+  const names: string[] = [];
+  for (const segment of path.split("/")) {
+    if (segment.startsWith(":") && segment.length > 1) {
+      names.push(segment.slice(1));
+    }
+  }
+  return names;
+}
+
+/**
+ * Parse JSON / text body. Empty body → `undefined`.
+ *
+ * @param request - Incoming request
+ */
+export async function parseBody(request: Request): Promise<unknown> {
+  const text = await request.text();
+  if (text.length === 0) return undefined;
+  try {
+    return JSON.parse(text) as unknown;
+  } catch {
+    return text;
+  }
+}
+
+/**
+ * Parse the query string into a flat string map.
+ *
+ * @param request - Incoming request
+ */
+export function parseQuery(request: Request): Record<string, string> {
+  const url = new URL(request.url);
+  const out: Record<string, string> = {};
+  for (const [key, value] of url.searchParams) {
+    out[key] = value;
+  }
+  return out;
+}
+
+/**
+ * Lower-cased header map (first value wins).
+ *
+ * @param request - Incoming request
+ */
+export function parseHeaders(request: Request): Record<string, string> {
+  const out: Record<string, string> = {};
+  request.headers.forEach((value, key) => {
+    out[key.toLowerCase()] = value;
+  });
+  return out;
+}
+
+/**
+ * Parse `Cookie` header into a name → value map.
+ *
+ * @param request - Incoming request
+ */
+export function parseCookie(request: Request): Record<string, string> {
+  const raw = request.headers.get("cookie");
+  if (!raw) return {};
+  const out: Record<string, string> = {};
+  for (const part of raw.split(";")) {
+    const idx = part.indexOf("=");
+    if (idx === -1) continue;
+    const key = part.slice(0, idx).trim();
+    const value = part.slice(idx + 1).trim();
+    if (key) out[key] = value;
+  }
+  return out;
+}
+
+/**
+ * Assemble handler input from extracted parts.
+ *
+ * Order: params → query → body fields (object merge) → headers/cookie bags.
+ * Matches the historical `oke().fetch` merge so AoT and dynamic agree.
+ *
+ * @param parts - Extracted request parts
+ */
+export function assembleInput(parts: InputParts): unknown {
+  const out: Record<string, unknown> = {};
+
+  if (parts.params !== undefined) {
+    Object.assign(out, parts.params);
+  }
+  if (parts.query !== undefined) {
+    Object.assign(out, parts.query);
+  }
+
+  if (parts.body !== undefined) {
+    if (
+      typeof parts.body === "object" &&
+      parts.body !== null &&
+      !Array.isArray(parts.body)
+    ) {
+      Object.assign(out, parts.body as Record<string, unknown>);
+    } else {
+      out.body = parts.body;
+    }
+  }
+
+  if (parts.headers !== undefined) {
+    out.headers = parts.headers;
+  }
+  if (parts.cookie !== undefined) {
+    out.cookie = parts.cookie;
+  }
+
+  if (Object.keys(out).length === 0) {
+    return parts.body !== undefined ? parts.body : undefined;
+  }
+  return out;
+}
+
+/**
+ * Extract request parts according to inference flags.
+ *
+ * @param request - Incoming request
+ * @param params - Router path params
+ * @param inference - Which slots to populate
+ */
+export async function extractParts(
+  request: Request,
+  params: Readonly<Record<string, string>>,
+  inference: ContextInference,
+): Promise<InputParts> {
+  const parts: {
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+    headers?: Record<string, string>;
+    cookie?: Record<string, string>;
+    body?: unknown;
+  } = {};
+
+  if (inference.params) parts.params = { ...params };
+  if (inference.query) parts.query = parseQuery(request);
+  if (inference.headers) parts.headers = parseHeaders(request);
+  if (inference.cookie) parts.cookie = parseCookie(request);
+  if (inference.body) parts.body = await parseBody(request);
+
+  return parts;
+}

package/src/compiler/index.ts

@@ -0,0 +1,67 @@
+/**
+ * Compiler: Manifest extraction (oxc) · AoT (Sucrose + `new Function`) · dynamic fallback.
+ */
+
+export {
+  compileAot,
+  createInterpretedParseValidate,
+  sucrose,
+  type CompiledParseValidate,
+  type CompiledRoute,
+  type CompileRouteOptions,
+  type ContextInference,
+  type ParseValidateResult,
+  type SucroseOptions,
+} from "./aot.ts";
+
+export {
+  compileDynamic,
+  compileRoute,
+  FULL_INFERENCE,
+} from "./dynamic.ts";
+
+export {
+  assembleInput,
+  emptyInference,
+  extractParts,
+  mergeInference,
+  parseBody,
+  parseCookie,
+  parseHeaders,
+  parseQuery,
+  pathParamNames,
+  type InputParts,
+  type MutableInference,
+} from "./http-parse.ts";
+
+export {
+  encodeExecuteResult,
+  encodeFailure,
+  encodeSuccess,
+  statusForFailure,
+  type FailureEnvelope,
+  type SuccessEnvelope,
+} from "./response.ts";
+
+export {
+  deepMatch,
+  extractFromSources,
+  extractManifest,
+  lineAt,
+  type ExtractManifestOptions,
+  type SourceFile,
+} from "./extract.ts";
+
+export {
+  inferEffects,
+  type InferBinding,
+  type InferEffectsOptions,
+  type InferredEffects,
+} from "./effects-infer.ts";
+
+export {
+  emitManifest,
+  manifestPathIn,
+  MANIFEST_FILENAME,
+  type EmitManifestOptions,
+} from "./emit.ts";

package/src/compiler/response.ts

@@ -0,0 +1,89 @@
+/**
+ * Canonical HTTP encoding for flow results.
+ *
+ * Shared by AoT and dynamic so responses stay byte-identical.
+ */
+
+import type { FlowFailure } from "../kernel/errors.ts";
+import { isFlowFailure } from "../kernel/hooks.ts";
+import { VALIDATION_ERROR_CODE } from "../validation/standard-schema.ts";
+
+/** Successful envelope. */
+export interface SuccessEnvelope {
+  readonly data: unknown;
+  readonly error: null;
+}
+
+/** Failure envelope. */
+export interface FailureEnvelope {
+  readonly data: null;
+  readonly error: FlowFailure["error"];
+}
+
+/**
+ * HTTP status for a flow-boundary failure.
+ *
+ * Gate denials use the status the Gates simulator promises:
+ * `Unauthorized` → 401 · `Forbidden` → 403 · `RateLimited` → 429.
+ *
+ * @param failure - Typed failure
+ */
+export function statusForFailure(failure: FlowFailure): number {
+  switch (failure.error.code) {
+    case VALIDATION_ERROR_CODE:
+      return 422;
+    case "Unauthorized":
+      return 401;
+    case "Forbidden":
+      return 403;
+    case "RateLimited":
+      return 429;
+    default:
+      return 400;
+  }
+}
+
+/**
+ * Encode a successful output as JSON `{ data, error: null }`.
+ *
+ * @param output - Handler output (`undefined` → 204)
+ */
+export function encodeSuccess(output: unknown): Response {
+  if (output === undefined) {
+    return new Response(null, { status: 204 });
+  }
+  return Response.json(
+    { data: output, error: null } satisfies SuccessEnvelope,
+  );
+}
+
+/**
+ * Encode a typed flow failure as JSON `{ data: null, error }`.
+ *
+ * @param failure - Flow-boundary failure
+ */
+export function encodeFailure(failure: FlowFailure): Response {
+  return Response.json(
+    { data: null, error: failure.error } satisfies FailureEnvelope,
+    { status: statusForFailure(failure) },
+  );
+}
+
+/**
+ * Encode an execute-style result (response / failure / output).
+ *
+ * @param result - Pipeline outcome pieces
+ */
+export function encodeExecuteResult(result: {
+  readonly response?: Response | undefined;
+  readonly failure?: FlowFailure | undefined;
+  readonly output?: unknown;
+  readonly error?: unknown;
+}): Response {
+  if (result.response) return result.response;
+  if (result.failure) return encodeFailure(result.failure);
+  if (result.error !== undefined && isFlowFailure(result.error)) {
+    return encodeFailure(result.error);
+  }
+  return encodeSuccess(result.output);
+}

package/src/compiler/sucrose.ts

@@ -0,0 +1,238 @@
+/**
+ * Sucrose-style static analysis — which context properties a handler uses.
+ *
+ * Reads `Function.toString()` and pattern-matches property access /
+ * destructuring. Conservative: unknown shapes enable all slots.
+ */
+
+import {
+  emptyInference,
+  FULL_INFERENCE,
+  mergeInference,
+  pathParamNames,
+  type ContextInference,
+  type MutableInference,
+} from "./http-parse.ts";
+
+/** Context property names sucrose tracks. */
+const CONTEXT_KEYS = [
+  "body",
+  "query",
+  "params",
+  "headers",
+  "cookie",
+] as const;
+
+type ContextKey = (typeof CONTEXT_KEYS)[number];
+
+/** Options for {@link sucrose}. */
+export interface SucroseOptions {
+  /** Primary route handler (`flow.do` or compose wrapper). */
+  readonly handler: (...args: never[]) => unknown;
+  /** Additional lifecycle functions to analyse. */
+  readonly hooks?: ReadonlyArray<(...args: never[]) => unknown>;
+  /** HTTP path — enables `params` when `:name` tokens appear. */
+  readonly path?: string;
+  /** HTTP method — influences default body inference. */
+  readonly method?: string;
+  /** True when an `in` schema is present. */
+  readonly hasSchema?: boolean;
+}
+
+/**
+ * Analyse handlers and return which request context slots are needed.
+ *
+ * @param options - Handler / hooks / route metadata
+ */
+export function sucrose(options: SucroseOptions): ContextInference {
+  const inference = emptyInference();
+
+  analyseFunction(options.handler, inference);
+  for (const hook of options.hooks ?? []) {
+    analyseFunction(hook, inference);
+  }
+
+  const pathParams = options.path ? pathParamNames(options.path) : [];
+  if (pathParams.length > 0) {
+    inference.params = true;
+  }
+
+  const method = (options.method ?? "GET").toUpperCase();
+  const bodyMethod =
+    method !== "GET" && method !== "HEAD" && method !== "DELETE";
+
+  // OKE handlers receive assembled input as arg0 — body methods always
+  // parse JSON. AoT still drops query/headers/cookie when unused.
+  if (bodyMethod) {
+    inference.body = true;
+  }
+
+  if (options.hasSchema && !bodyMethod) {
+    // GET/HEAD/DELETE with a contract: path params and/or query
+    if (!inference.params && !inference.query) {
+      inference.query = true;
+    }
+  }
+
+  return inference;
+}
+
+/**
+ * Analyse a single function into `inference` (OR-merge).
+ *
+ * @param fn - Function to inspect
+ * @param inference - Accumulator
+ */
+export function analyseFunction(
+  fn: (...args: never[]) => unknown,
+  inference: MutableInference,
+): void {
+  let source: string;
+  try {
+    source = Function.prototype.toString.call(fn);
+  } catch {
+    mergeInference(inference, FULL_INFERENCE);
+    return;
+  }
+
+  if (!source || source.includes("[native code]")) {
+    mergeInference(inference, FULL_INFERENCE);
+    return;
+  }
+
+  const { parameter, body } = splitFunction(source);
+  if (parameter === undefined || body === undefined) {
+    mergeInference(inference, FULL_INFERENCE);
+    return;
+  }
+
+  const aliases = collectAliases(parameter, body);
+
+  if (isContextPassedToFunction(aliases, body)) {
+    mergeInference(inference, FULL_INFERENCE);
+    return;
+  }
+
+  for (const alias of aliases) {
+    inferFromAlias(alias, body, inference);
+  }
+
+  // Destructuring in the parameter list: ({ body, query, id })
+  inferFromDestructure(parameter, inference);
+}
+
+function splitFunction(
+  source: string,
+): { parameter: string | undefined; body: string | undefined } {
+  // async (a, b) => … | (a) => … | function (a, b) { … }
+  const arrow = source.match(
+    /^(?:async\s*)?(?:\(([^)]*)\)|([a-zA-Z_$][\w$]*))\s*=>\s*([\s\S]*)$/,
+  );
+  if (arrow) {
+    return {
+      parameter: (arrow[1] ?? arrow[2] ?? "").trim(),
+      body: arrow[3] ?? "",
+    };
+  }
+  const classic = source.match(
+    /^(?:async\s*)?function\s*(?:[a-zA-Z_$][\w$]*)?\s*\(([^)]*)\)\s*\{([\s\S]*)\}$/,
+  );
+  if (classic) {
+    return {
+      parameter: (classic[1] ?? "").trim(),
+      body: classic[2] ?? "",
+    };
+  }
+  return { parameter: undefined, body: undefined };
+}
+
+function collectAliases(parameter: string, body: string): string[] {
+  const aliases: string[] = [];
+  // First parameter only (context / input)
+  const first = parameter.split(",")[0]?.trim() ?? "";
+  if (!first) return aliases;
+
+  if (first.startsWith("{")) {
+    // Destructured — no alias; property keys handled separately
+    return aliases;
+  }
+
+  const name = first.replace(/\s*=\s*[\s\S]*$/, "").trim();
+  if (/^[a-zA-Z_$][\w$]*$/.test(name)) {
+    aliases.push(name);
+  }
+
+  // const x = input / let x = input
+  for (const alias of aliases.slice()) {
+    const re = new RegExp(
+      `\\b(?:const|let|var)\\s+([a-zA-Z_$][\\w$]*)\\s*=\\s*${escapeRegExp(alias)}\\b`,
+      "g",
+    );
+    for (const match of body.matchAll(re)) {
+      const next = match[1];
+      if (next) aliases.push(next);
+    }
+  }
+
+  return aliases;
+}
+
+function inferFromAlias(
+  alias: string,
+  body: string,
+  inference: MutableInference,
+): void {
+  for (const key of CONTEXT_KEYS) {
+    if (inference[key]) continue;
+    const access = new RegExp(
+      `${escapeRegExp(alias)}\\s*(?:\\.\\s*${key}|\\[\\s*['"]${key}['"]\\s*\\])`,
+    );
+    if (access.test(body)) {
+      inference[key] = true;
+    }
+  }
+}
+
+function inferFromDestructure(
+  parameter: string,
+  inference: MutableInference,
+): void {
+  if (!parameter.includes("{")) return;
+  for (const key of CONTEXT_KEYS) {
+    const re = new RegExp(`\\b${key}\\b`);
+    if (re.test(parameter)) {
+      inference[key as ContextKey] = true;
+    }
+  }
+}
+
+function isContextPassedToFunction(
+  aliases: readonly string[],
+  body: string,
+): boolean {
+  for (const alias of aliases) {
+    if (alias.length === 0) continue;
+    // Word-boundary safe: `(…, alias, …)` or `(alias)` as a complete argument
+    const re = new RegExp(
+      `(?:^|[^\\w$])\\w+\\s*\\([^)]*(?:^|[,(\\s])${escapeRegExp(alias)}(?:[,)\\s])`,
+    );
+    if (re.test(body)) return true;
+    // shorthand: fn(alias)
+    const exact = new RegExp(
+      `\\(\\s*${escapeRegExp(alias)}\\s*\\)`,
+    );
+    if (exact.test(body)) return true;
+  }
+  return false;
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Inference for the dynamic path — always full (no dead-code elimination).
+ */
+export function dynamicInference(): ContextInference {
+  return FULL_INFERENCE;
+}