@slopware/sloppy 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,17 @@
+Sloppy is licensed under the Apache License, Version 2.0.
+The full text is available in the project root LICENSE file and at
+http://www.apache.org/licenses/LICENSE-2.0.
+
+Copyright 2026 The Sloppy Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied. See the License for the specific language governing permissions
+and limitations under the License.

package/README.md

@@ -0,0 +1,25 @@
+# @slopware/sloppy
+
+This package is a thin launcher for installing the Sloppy runtime. It selects an installed
+platform package and forwards arguments to the packaged `sloppy` binary.
+
+The alpha root package references supported platform packages for Windows x64,
+Linux x64 GNU, and macOS. Platform packages contain the native CLI binaries,
+bootstrap stdlib, built-in project templates, selected docs/examples,
+manifest, and license files. The launcher sets `SLOPPY_SLOPPYC` so commands
+such as `sloppy create`, `sloppy build`, and `sloppy package` work outside a
+repository checkout.
+
+The root package includes TypeScript declarations for the public starter
+surface (`sloppy`, `sloppy/data`, `sloppy/fs`, `sloppy/os`, and
+`sloppy/providers/sqlite`) so app workspaces can install it as a local dev
+dependency for editor IntelliSense.
+
+npm is only a distribution channel for Sloppy itself. Sloppy apps can bundle
+compatible already-installed pure-JavaScript packages when their imports fit
+Sloppy's resolver, module loader, and runtime boundary. Sloppy does not install
+packages from a registry, solve semver, support Node native addons/N-API, or
+claim full Node compatibility in this alpha track.
+
+The package has no native install script, no `node-gyp`, and no postinstall V8 build or
+download.

package/bin/sloppy.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+"use strict";
+
+const { spawnSync } = require("node:child_process");
+const path = require("node:path");
+const { resolvePlatformPackage } = require("../lib/platform");
+
+function main() {
+  const selected = resolvePlatformPackage(process.env, process.platform, process.arch);
+  if (!selected.supported) {
+    console.error(selected.message);
+    return 1;
+  }
+
+  let packageJsonPath;
+  try {
+    packageJsonPath = require.resolve(`${selected.packageName}/package.json`);
+  } catch {
+    console.error(
+      `Sloppy runtime platform package '${selected.packageName}' is not installed. ` +
+        "Install the matching @slopware/sloppy platform package generated from a tested release archive."
+    );
+    return 1;
+  }
+
+  const packageRoot = path.dirname(packageJsonPath);
+  const platformBin = path.join(packageRoot, "bin");
+  const executable = path.join(platformBin, process.platform === "win32" ? "sloppy.exe" : "sloppy");
+  const sloppyc = path.join(platformBin, process.platform === "win32" ? "sloppyc.exe" : "sloppyc");
+  const pathKey = Object.keys(process.env).find((key) => /^path$/i.test(key)) || "PATH";
+  const currentPath = process.env[pathKey] || "";
+  const childEnv = {
+    ...process.env,
+    [pathKey]: `${platformBin}${path.delimiter}${currentPath}`,
+    SLOPPY_SLOPPYC: process.env.SLOPPY_SLOPPYC || sloppyc
+  };
+  const result = spawnSync(executable, process.argv.slice(2), { stdio: "inherit", env: childEnv });
+  if (result.error) {
+    console.error(`Failed to run packaged Sloppy binary '${executable}': ${result.error.message}`);
+    return 1;
+  }
+  return typeof result.status === "number" ? result.status : 1;
+}
+
+process.exitCode = main();

package/lib/platform.js

@@ -0,0 +1,57 @@
+"use strict";
+
+function effectivePlatform(env, processPlatform) {
+  return env.SLOPPY_RUNTIME_PLATFORM || processPlatform;
+}
+
+function effectiveArch(env, processArch) {
+  return env.SLOPPY_RUNTIME_ARCH || processArch;
+}
+
+function effectiveLibc(env, platform) {
+  if (env.SLOPPY_RUNTIME_LIBC) {
+    return env.SLOPPY_RUNTIME_LIBC;
+  }
+  if (platform !== "linux") {
+    return "";
+  }
+  if (
+    typeof process !== "undefined" &&
+    process.report &&
+    typeof process.report.getReport === "function"
+  ) {
+    const report = process.report.getReport();
+    if (report && report.header && report.header.glibcVersionRuntime) {
+      return "gnu";
+    }
+  }
+  return "musl";
+}
+
+function resolvePlatformPackage(env, processPlatform, processArch) {
+  const platform = effectivePlatform(env, processPlatform);
+  const arch = effectiveArch(env, processArch);
+  const libc = effectiveLibc(env, platform);
+
+  if (platform === "win32" && arch === "x64") {
+    return { supported: true, packageName: "@slopware/sloppy-win32-x64" };
+  }
+  if (platform === "linux" && arch === "x64" && libc === "gnu") {
+    return { supported: true, packageName: "@slopware/sloppy-linux-x64" };
+  }
+  if (platform === "darwin" && arch === "arm64") {
+    return { supported: true, packageName: "@slopware/sloppy-darwin-arm64" };
+  }
+  if (platform === "darwin" && arch === "x64") {
+    return { supported: true, packageName: "@slopware/sloppy-darwin-x64" };
+  }
+
+  return {
+    supported: false,
+    message:
+      `Unsupported Sloppy runtime npm platform: platform=${platform} arch=${arch} libc=${libc}. ` +
+      "Use a GitHub Release archive or build Sloppy from source for this platform."
+  };
+}
+
+module.exports = { resolvePlatformPackage };

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@slopware/sloppy",
+  "version": "0.1.0-alpha.0",
+  "description": "Sloppy runtime launcher. npm installs Sloppy itself; it does not add npm package support to Sloppy apps.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RtlZeroMemory/Slop.git"
+  },
+  "bin": {
+    "sloppy": "bin/sloppy.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "types/",
+    "LICENSE",
+    "README.md",
+    "package.json"
+  ],
+  "optionalDependencies": {
+    "@slopware/sloppy-win32-x64": "0.1.0-alpha.0",
+    "@slopware/sloppy-linux-x64": "0.1.0-alpha.0",
+    "@slopware/sloppy-darwin-arm64": "0.1.0-alpha.0",
+    "@slopware/sloppy-darwin-x64": "0.1.0-alpha.0"
+  },
+  "publishConfig": {
+    "tag": "alpha",
+    "access": "public"
+  },
+  "types": "types/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "os": [
+        "types/os.d.ts"
+      ],
+      "fs": [
+        "types/fs.d.ts"
+      ],
+      "data": [
+        "types/data.d.ts"
+      ],
+      "providers/sqlite": [
+        "types/providers/sqlite.d.ts"
+      ]
+    }
+  }
+}

package/types/data.d.ts

@@ -0,0 +1,24 @@
+export interface SqlFragment {
+  readonly __sloppySql?: true;
+}
+
+export interface MigrationOptions {
+  provider?: string;
+  path?: string;
+  [key: string]: unknown;
+}
+
+export const sql: {
+  sqlite(strings: TemplateStringsArray, ...values: unknown[]): SqlFragment;
+  postgres(strings: TemplateStringsArray, ...values: unknown[]): SqlFragment;
+  sqlserver(strings: TemplateStringsArray, ...values: unknown[]): SqlFragment;
+};
+
+export const data: Record<string, unknown>;
+export const Migrations: {
+  apply(database: unknown, options?: MigrationOptions): Promise<unknown>;
+  run(options?: MigrationOptions): Promise<unknown>;
+  status(options?: MigrationOptions): Promise<unknown>;
+};
+export const ProviderHealth: Record<string, unknown>;
+export function isRealDataProvider(value: unknown): boolean;

package/types/fs.d.ts

@@ -0,0 +1,23 @@
+export const File: {
+  readText(path: string, options?: Record<string, unknown>): Promise<string>;
+  writeText(path: string, value: string, options?: Record<string, unknown>): Promise<void>;
+  readBytes(path: string, options?: Record<string, unknown>): Promise<Uint8Array>;
+  writeBytes(path: string, value: Uint8Array | ArrayBuffer, options?: Record<string, unknown>): Promise<void>;
+  exists(path: string): Promise<boolean>;
+};
+
+export const Directory: {
+  create(path: string, options?: Record<string, unknown>): Promise<void>;
+  exists(path: string): Promise<boolean>;
+  entries(path: string, options?: Record<string, unknown>): Promise<string[]>;
+};
+
+export const Path: {
+  join(...parts: string[]): string;
+  dirname(path: string): string;
+  basename(path: string): string;
+  extname(path: string): string;
+};
+
+export const FileHandle: Record<string, unknown>;
+export const FileWatcher: Record<string, unknown>;

package/types/index.d.ts

@@ -0,0 +1,177 @@
+/// <reference path="./providers/sqlite.d.ts" />
+/// <reference path="./sloppy.d.ts" />
+
+export type Awaitable<T> = T | Promise<T>;
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };
+
+export type Route<T = string> = T;
+export type Query<T = string> = T;
+export type Header<T = string> = T;
+export type Body<T = unknown> = T;
+export type Service<T = unknown> = T;
+
+export interface SloppyRequest {
+  method: string;
+  path: string;
+  headers?: Record<string, string>;
+  query?: Record<string, string | string[]>;
+  body?: unknown;
+}
+
+export interface RequestBody<T = unknown> {
+  value?: T;
+  text(): Promise<string>;
+  json<TJson = unknown>(): Promise<TJson>;
+  validate<TValue>(schema: SchemaType<TValue>): Promise<TValue>;
+}
+
+export interface RequestContext {
+  request: SloppyRequest;
+  route: Record<string, string>;
+  routeName?: string;
+  requestId?: string;
+  services?: Record<string, unknown>;
+  body: RequestBody;
+  log?: {
+    debug(message: string, fields?: Record<string, unknown>): void;
+    info(message: string, fields?: Record<string, unknown>): void;
+    warn(message: string, fields?: Record<string, unknown>): void;
+    error(message: string, fields?: Record<string, unknown>): void;
+  };
+}
+
+export interface ResultDescriptor<TBody = unknown> {
+  readonly __sloppyResult?: true;
+  readonly kind?: string;
+  readonly status?: number;
+  readonly headers?: Record<string, string>;
+  readonly contentType?: string;
+  readonly body?: TBody;
+}
+
+export type Handler<T = unknown> = (ctx: RequestContext) => Awaitable<T | ResultDescriptor<T>>;
+export type Middleware = (ctx: RequestContext, next: () => Awaitable<ResultDescriptor>) => Awaitable<ResultDescriptor>;
+
+export interface RouteBuilder {
+  withName(name: string): RouteBuilder;
+  withTags(...tags: string[]): RouteBuilder;
+  produces(status: number, contentType?: string): RouteBuilder;
+  accepts(schema: SchemaType, options?: Record<string, unknown>): RouteBuilder;
+  returns(schema: SchemaType, options?: Record<string, unknown>): RouteBuilder;
+}
+
+export interface RouteGroup {
+  use(middleware: Middleware): RouteGroup;
+  get(path: string, handler: Handler): RouteBuilder;
+  post(path: string, handler: Handler): RouteBuilder;
+  put(path: string, handler: Handler): RouteBuilder;
+  patch(path: string, handler: Handler): RouteBuilder;
+  delete(path: string, handler: Handler): RouteBuilder;
+  group(prefix: string): RouteGroup;
+}
+
+export interface SloppyApp extends RouteGroup {
+  useCors(options?: Record<string, unknown>): SloppyApp;
+  useErrors(options?: Record<string, unknown>): SloppyApp;
+  useStaticFiles(options: Record<string, unknown>): SloppyApp;
+  useModule(module: (app: SloppyApp) => void): SloppyApp;
+  provider<T = unknown>(name: string): T;
+  mapController(prefix: string, controller: new (...args: any[]) => unknown, configure: (mapper: any) => void): SloppyApp;
+}
+
+export interface ServiceBuilder {
+  addSingleton<T>(name: string, factory: () => T): ServiceBuilder;
+  addScoped<T>(name: string, factory: () => T): ServiceBuilder;
+  addTransient<T>(name: string, factory: () => T): ServiceBuilder;
+}
+
+export interface SloppyBuilder {
+  services: ServiceBuilder;
+  build(): SloppyApp;
+}
+
+export const Sloppy: {
+  create(options?: Record<string, unknown>): SloppyApp;
+  createBuilder(options?: Record<string, unknown>): SloppyBuilder;
+};
+
+export const Router: {
+  group(prefix: string): RouteGroup;
+};
+
+export const Results: {
+  ok<T = unknown>(value?: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+  json<T = unknown>(value: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+  text(value: string, options?: Record<string, unknown>): ResultDescriptor<string>;
+  html(value: string, options?: Record<string, unknown>): ResultDescriptor<string>;
+  bytes(value: Uint8Array | ArrayBuffer, options?: Record<string, unknown>): ResultDescriptor<Uint8Array | ArrayBuffer>;
+  created<T = unknown>(location: string, value?: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+  created<T = unknown>(value?: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+  accepted<T = unknown>(value?: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+  noContent(options?: Record<string, unknown>): ResultDescriptor<void>;
+  notFound<T = unknown>(value?: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+  badRequest<T = unknown>(value?: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+  unauthorized<T = unknown>(value?: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+  status<T = unknown>(statusCode: number, value?: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+  problem(problemOrMessage: string | Record<string, unknown>, options?: Record<string, unknown>): ResultDescriptor<Record<string, unknown>>;
+};
+
+export interface SchemaValidation<T> {
+  ok: boolean;
+  value?: T;
+  issues?: Array<{ path: Array<string | number>; code: string; message: string }>;
+}
+
+export interface SchemaType<T = unknown> {
+  readonly kind: string;
+  readonly metadata: Record<string, unknown>;
+  validate(value: unknown): SchemaValidation<T>;
+  optional(): SchemaType<T | undefined>;
+  nullable(): SchemaType<T | null>;
+  default(value: T): SchemaType<T>;
+  min(value: number): SchemaType<T>;
+  max(value: number): SchemaType<T>;
+  email(): SchemaType<T>;
+}
+
+export const Schema: {
+  string(): SchemaType<string>;
+  number(): SchemaType<number>;
+  int(): SchemaType<number>;
+  integer(): SchemaType<number>;
+  boolean(): SchemaType<boolean>;
+  bool(): SchemaType<boolean>;
+  array<T>(item: SchemaType<T>): SchemaType<T[]>;
+  enum<T extends string | number | boolean | null>(values: readonly T[]): SchemaType<T>;
+  literal<T extends string | number | boolean | null>(value: T): SchemaType<T>;
+  object<T extends Record<string, SchemaType>>(shape: T): SchemaType<{ [K in keyof T]: T[K] extends SchemaType<infer V> ? V : never }>;
+  validate<T>(value: unknown, schema: SchemaType<T>): T;
+  isSchema(value: unknown): value is SchemaType;
+};
+
+export const schema: typeof Schema;
+
+export const RequestId: {
+  defaults(options?: Record<string, unknown>): Middleware;
+};
+
+export const RequestLogging: {
+  defaults(options?: Record<string, unknown>): Middleware;
+};
+
+export const ProblemDetails: {
+  defaults(options?: Record<string, unknown>): Middleware;
+};
+export const Auth: Record<string, unknown>;
+export const Config: Record<string, unknown>;
+export const Health: Record<string, unknown>;
+export const Metrics: Record<string, unknown>;
+export const RateLimit: Record<string, unknown>;
+export const Realtime: Record<string, unknown>;
+export const Webhooks: Record<string, unknown>;
+export const Testing: Record<string, unknown>;
+
+export * from "./data";
+export * from "./fs";
+export * from "./os";

package/types/os.d.ts

@@ -0,0 +1,14 @@
+export const Environment: {
+  get(name: string, fallback?: string): string | undefined;
+  require(name: string): string;
+};
+
+export const System: {
+  platform(): string;
+  arch(): string;
+  cwd(): string;
+};
+
+export const Process: Record<string, unknown>;
+export const Signals: Record<string, unknown>;
+export class OsError extends Error {}

package/types/providers/sqlite.d.ts

@@ -0,0 +1,8 @@
+export interface SqliteProviderOptions {
+  database?: string;
+  readonly?: boolean;
+  migrations?: string;
+  [key: string]: unknown;
+}
+
+export function sqlite(name: string, options?: SqliteProviderOptions): any;

package/types/sloppy.d.ts

@@ -0,0 +1,244 @@
+declare module "sloppy" {
+  export type Awaitable<T> = T | Promise<T>;
+  export type JsonPrimitive = string | number | boolean | null;
+  export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };
+
+  export type Route<T = string> = T;
+  export type Query<T = string> = T;
+  export type Header<T = string> = T;
+  export type Body<T = unknown> = T;
+  export type Service<T = unknown> = T;
+
+  export interface SloppyRequest {
+    method: string;
+    path: string;
+    headers?: Record<string, string>;
+    query?: Record<string, string | string[]>;
+    body?: unknown;
+  }
+
+  export interface SchemaValidation<T> {
+    ok: boolean;
+    value?: T;
+    issues?: Array<{ path: Array<string | number>; code: string; message: string }>;
+  }
+
+  export interface SchemaType<T = unknown> {
+    readonly kind: string;
+    readonly metadata: Record<string, unknown>;
+    validate(value: unknown): SchemaValidation<T>;
+    optional(): SchemaType<T | undefined>;
+    nullable(): SchemaType<T | null>;
+    default(value: T): SchemaType<T>;
+    min(value: number): SchemaType<T>;
+    max(value: number): SchemaType<T>;
+    email(): SchemaType<T>;
+  }
+
+  export interface RequestBody<T = unknown> {
+    value?: T;
+    text(): Promise<string>;
+    json<TJson = unknown>(): Promise<TJson>;
+    validate<TValue>(schema: SchemaType<TValue>): Promise<TValue>;
+  }
+
+  export interface RequestContext {
+    request: SloppyRequest;
+    route: Record<string, string>;
+    routeName?: string;
+    requestId?: string;
+    services?: Record<string, unknown>;
+    body: RequestBody;
+    log?: {
+      debug(message: string, fields?: Record<string, unknown>): void;
+      info(message: string, fields?: Record<string, unknown>): void;
+      warn(message: string, fields?: Record<string, unknown>): void;
+      error(message: string, fields?: Record<string, unknown>): void;
+    };
+  }
+
+  export interface ResultDescriptor<TBody = unknown> {
+    readonly __sloppyResult?: true;
+    readonly kind?: string;
+    readonly status?: number;
+    readonly headers?: Record<string, string>;
+    readonly contentType?: string;
+    readonly body?: TBody;
+  }
+
+  export type Handler<T = unknown> = (ctx: RequestContext) => Awaitable<T | ResultDescriptor<T>>;
+  export type Middleware = (ctx: RequestContext, next: () => Awaitable<ResultDescriptor>) => Awaitable<ResultDescriptor>;
+
+  export interface RouteBuilder {
+    withName(name: string): RouteBuilder;
+    withTags(...tags: string[]): RouteBuilder;
+    produces(status: number, contentType?: string): RouteBuilder;
+    accepts(schema: SchemaType, options?: Record<string, unknown>): RouteBuilder;
+    returns(schema: SchemaType, options?: Record<string, unknown>): RouteBuilder;
+  }
+
+  export interface RouteGroup {
+    use(middleware: Middleware): RouteGroup;
+    get(path: string, handler: Handler): RouteBuilder;
+    post(path: string, handler: Handler): RouteBuilder;
+    put(path: string, handler: Handler): RouteBuilder;
+    patch(path: string, handler: Handler): RouteBuilder;
+    delete(path: string, handler: Handler): RouteBuilder;
+    group(prefix: string): RouteGroup;
+  }
+
+  export interface SloppyApp extends RouteGroup {
+    useCors(options?: Record<string, unknown>): SloppyApp;
+    useErrors(options?: Record<string, unknown>): SloppyApp;
+    useStaticFiles(options: Record<string, unknown>): SloppyApp;
+    useModule(module: (app: SloppyApp) => void): SloppyApp;
+    provider<T = unknown>(name: string): T;
+    mapController(prefix: string, controller: new (...args: any[]) => unknown, configure: (mapper: any) => void): SloppyApp;
+  }
+
+  export interface ServiceBuilder {
+    addSingleton<T>(name: string, factory: () => T): ServiceBuilder;
+    addScoped<T>(name: string, factory: () => T): ServiceBuilder;
+    addTransient<T>(name: string, factory: () => T): ServiceBuilder;
+  }
+
+  export interface SloppyBuilder {
+    services: ServiceBuilder;
+    build(): SloppyApp;
+  }
+
+  export const Sloppy: {
+    create(options?: Record<string, unknown>): SloppyApp;
+    createBuilder(options?: Record<string, unknown>): SloppyBuilder;
+  };
+
+  export const Router: {
+    group(prefix: string): RouteGroup;
+  };
+
+  export const Results: {
+    ok<T = unknown>(value?: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+    json<T = unknown>(value: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+    text(value: string, options?: Record<string, unknown>): ResultDescriptor<string>;
+    html(value: string, options?: Record<string, unknown>): ResultDescriptor<string>;
+    bytes(value: Uint8Array | ArrayBuffer, options?: Record<string, unknown>): ResultDescriptor<Uint8Array | ArrayBuffer>;
+    created<T = unknown>(location: string, value?: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+    created<T = unknown>(value?: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+    accepted<T = unknown>(value?: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+    noContent(options?: Record<string, unknown>): ResultDescriptor<void>;
+    notFound<T = unknown>(value?: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+    badRequest<T = unknown>(value?: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+    unauthorized<T = unknown>(value?: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+    status<T = unknown>(statusCode: number, value?: T, options?: Record<string, unknown>): ResultDescriptor<T>;
+    problem(problemOrMessage: string | Record<string, unknown>, options?: Record<string, unknown>): ResultDescriptor<Record<string, unknown>>;
+  };
+
+  export const Schema: {
+    string(): SchemaType<string>;
+    number(): SchemaType<number>;
+    int(): SchemaType<number>;
+    integer(): SchemaType<number>;
+    boolean(): SchemaType<boolean>;
+    bool(): SchemaType<boolean>;
+    array<T>(item: SchemaType<T>): SchemaType<T[]>;
+    enum<T extends string | number | boolean | null>(values: readonly T[]): SchemaType<T>;
+    literal<T extends string | number | boolean | null>(value: T): SchemaType<T>;
+    object<T extends Record<string, SchemaType>>(shape: T): SchemaType<{ [K in keyof T]: T[K] extends SchemaType<infer V> ? V : never }>;
+    validate<T>(value: unknown, schema: SchemaType<T>): T;
+    isSchema(value: unknown): value is SchemaType;
+  };
+
+  export const schema: typeof Schema;
+  export const RequestId: { defaults(options?: Record<string, unknown>): Middleware };
+  export const RequestLogging: { defaults(options?: Record<string, unknown>): Middleware };
+  export const ProblemDetails: { defaults(options?: Record<string, unknown>): Middleware };
+  export const Auth: Record<string, unknown>;
+  export const Config: Record<string, unknown>;
+  export const Health: Record<string, unknown>;
+  export const Metrics: Record<string, unknown>;
+  export const RateLimit: Record<string, unknown>;
+  export const Realtime: Record<string, unknown>;
+  export const Webhooks: Record<string, unknown>;
+  export const Testing: Record<string, unknown>;
+}
+
+declare module "sloppy/data" {
+  export interface SqlFragment {
+    readonly __sloppySql?: true;
+  }
+
+  export interface MigrationOptions {
+    provider?: string;
+    path?: string;
+    [key: string]: unknown;
+  }
+
+  export const sql: {
+    sqlite(strings: TemplateStringsArray, ...values: unknown[]): SqlFragment;
+    postgres(strings: TemplateStringsArray, ...values: unknown[]): SqlFragment;
+    sqlserver(strings: TemplateStringsArray, ...values: unknown[]): SqlFragment;
+  };
+
+  export const data: Record<string, unknown>;
+  export const Migrations: {
+    apply(database: unknown, options?: MigrationOptions): Promise<unknown>;
+    run(options?: MigrationOptions): Promise<unknown>;
+    status(options?: MigrationOptions): Promise<unknown>;
+  };
+  export const ProviderHealth: Record<string, unknown>;
+  export function isRealDataProvider(value: unknown): boolean;
+}
+
+declare module "sloppy/fs" {
+  export const File: {
+    readText(path: string, options?: Record<string, unknown>): Promise<string>;
+    writeText(path: string, value: string, options?: Record<string, unknown>): Promise<void>;
+    readBytes(path: string, options?: Record<string, unknown>): Promise<Uint8Array>;
+    writeBytes(path: string, value: Uint8Array | ArrayBuffer, options?: Record<string, unknown>): Promise<void>;
+    exists(path: string): Promise<boolean>;
+  };
+
+  export const Directory: {
+    create(path: string, options?: Record<string, unknown>): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    entries(path: string, options?: Record<string, unknown>): Promise<string[]>;
+  };
+
+  export const Path: {
+    join(...parts: string[]): string;
+    dirname(path: string): string;
+    basename(path: string): string;
+    extname(path: string): string;
+  };
+
+  export const FileHandle: Record<string, unknown>;
+  export const FileWatcher: Record<string, unknown>;
+}
+
+declare module "sloppy/os" {
+  export const Environment: {
+    get(name: string, fallback?: string): string | undefined;
+    require(name: string): string;
+  };
+
+  export const System: {
+    platform(): string;
+    arch(): string;
+    cwd(): string;
+  };
+
+  export const Process: Record<string, unknown>;
+  export const Signals: Record<string, unknown>;
+  export class OsError extends Error {}
+}
+
+declare module "sloppy/providers/sqlite" {
+  export interface SqliteProviderOptions {
+    database?: string;
+    readonly?: boolean;
+    migrations?: string;
+    [key: string]: unknown;
+  }
+
+  export function sqlite(name: string, options?: SqliteProviderOptions): any;
+}