@slopware/sloppy-linux-x64 0.1.0-alpha.0

package/examples/workers-workerpool/README.md

@@ -0,0 +1,6 @@
+# Workers WorkerPool
+
+This example shows the `WorkerPool` API and bounded admission shape for CPU/native offload style work.
+
+Current bootstrap examples focus on API shape and lifecycle policy. Native CPU-parallel
+execution is validated in V8/native bridge checks.

package/examples/workers-workerpool/app.js

@@ -0,0 +1,23 @@
+import { Sloppy, Results } from "sloppy";
+import { Deadline } from "sloppy/time";
+import { WorkerPool } from "sloppy/workers";
+
+const app = Sloppy.create();
+
+const pool = WorkerPool.create("image-processing", {
+  workers: 4,
+  maxQueued: 100,
+});
+
+app.use(pool);
+app.mapPost("/images/resize", async () => {
+  const result = await pool.run(async (ctx) => {
+    return { bytes: ctx.input.length, resized: true };
+  }, {
+    input: new Uint8Array([1, 2, 3, 4]),
+    deadline: Deadline.after(5000),
+  });
+  return Results.json(result);
+});
+
+export default app;

package/examples/workers-workqueue/README.md

@@ -0,0 +1,8 @@
+# Workers WorkQueue
+
+This example shows the `WorkQueue` API shape.
+Shows a bounded in-process FIFO queue with explicit capacity, concurrency, overflow, and
+retry policy.
+
+Queue diagnostics and doctor output report policy metadata only; job payload values are not
+included in diagnostics or goldens.

package/examples/workers-workqueue/app.js

@@ -0,0 +1,24 @@
+import { Sloppy, Results } from "sloppy";
+import { WorkQueue } from "sloppy/workers";
+
+const app = Sloppy.create();
+
+const emails = WorkQueue.create("emails", {
+  maxQueued: 1000,
+  concurrency: 4,
+  overflow: "reject",
+  retry: { maxAttempts: 3, backoffMs: 0 },
+});
+
+emails.process(async (job, ctx) => {
+  ctx.signal.throwIfCancelled?.();
+  return { accepted: true, template: job.data.template };
+});
+
+app.use(emails);
+app.mapPost("/emails/welcome", async () => {
+  await emails.enqueue({ to: "user@example.com", template: "welcome" });
+  return Results.accepted({ queued: true });
+});
+
+export default app;

package/manifest.json

@@ -0,0 +1,59 @@
+{
+  "manifestSchema": "sloppy.release-artifact.v1",
+  "manifestVersion": 1,
+  "name": "sloppy",
+  "version": "0.1.0-alpha.0",
+  "archiveName": "sloppy-linux-x64.tar.gz",
+  "packageRoot": "sloppy-linux-x64",
+  "platform": "linux",
+  "arch": "x64",
+  "platformTriplet": "linux-x64",
+  "configuration": "Release",
+  "commit": "unknown",
+  "releaseKind": "dry-run",
+  "publicReleaseCreated": false,
+  "canonicalDistribution": "github-release-archive",
+  "npmPackageSource": "platform packages must be generated from this tested archive content",
+  "platformStatus": "experimental",
+  "runtimeUserStatus": "experimental V8 package smoke required",
+  "compiler": {
+    "name": "sloppyc",
+    "profile": "release",
+    "included": true
+  },
+  "v8": {
+    "sdkIncluded": false,
+    "runtimeIncluded": true,
+    "status": "linked runtime",
+    "version": "pinned by tools/deps/sloppy-deps.json",
+    "runtimeDirectory": "",
+    "notes": "Linux V8 runtime is provided by the Sloppy-owned SDK and linked into the packaged runtime"
+  },
+  "enabledFeatures": ["native-runtime", "stdlib", "compiler", "v8"],
+  "dependencyStatuses": {
+    "nativeRuntimeDependencies": "V8 linked into packaged runtime; platform system libraries remain host-provided",
+    "v8Sdk": "excluded",
+    "v8Runtime": "linked into packaged runtime",
+    "liveProviders": "not configured",
+    "runtimeDependencyAudit": "docs/release/runtime-dependency-audit.json"
+  },
+  "providers": {
+    "sqlite": "packaged runtime dependency status only; provider behavior evidence is separate",
+    "postgresql": "live-provider evidence is separate",
+    "sqlserver": "driver/runtime availability evidence is separate"
+  },
+  "containsV8Runtime": true,
+  "containsV8Sdk": false,
+  "containsStdlib": true,
+  "containsTemplates": true,
+  "containsExamples": true,
+  "containsNativeRuntimeDependencies": false,
+  "knownLimitations": "docs/KNOWN_LIMITATIONS.md",
+  "checksums": {
+    "file": "SHA256SUMS.txt",
+    "algorithm": "SHA-256"
+  },
+  "tools": ["sloppy", "sloppyc"],
+  "layoutVersion": 1,
+  "notes": ["experimental", "dry-run artifact", "production readiness tracked separately", "dry-run only", "no installer", "no package manager", "npm launcher packages may reuse this archive but do not install app dependencies or add runtime node_modules discovery"]
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@slopware/sloppy-linux-x64",
+  "version": "0.1.0-alpha.0",
+  "description": "Linux x64 GNU Sloppy runtime package generated from a tested release archive.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RtlZeroMemory/Slop.git"
+  },
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "libc": [
+    "glibc"
+  ],
+  "files": [
+    "bin/",
+    "stdlib/",
+    "templates/",
+    "examples/",
+    "docs/",
+    "manifest.json",
+    "LICENSE",
+    "README.md",
+    "package.json"
+  ],
+  "publishConfig": {
+    "tag": "alpha",
+    "access": "public"
+  }
+}

package/stdlib/sloppy/README.md

@@ -0,0 +1,177 @@
+# Sloppy Bootstrap Stdlib
+
+This directory contains the active bootstrap standard library and staged runtime asset set.
+This directory contains the source-controlled JavaScript facade used by bootstrap tests,
+examples, compiler fixtures, and staged runtime assets. It is the Sloppy
+bootstrap facade for the current runtime surface.
+
+## Layout
+
+```text
+stdlib/sloppy/
+  index.js
+  app.js
+  results.js
+  schema.js
+  cache.js
+  testing.js
+  testservices.js
+  data.js
+  orm.js
+  redis.js
+  fs.js
+  http.js
+  net.js
+  problem-details.js
+  request-id.js
+  request-logging.js
+  time.js
+  codec.js
+  crypto.js
+  os.js
+  workers.js
+  health.js
+  metrics.js
+  webhooks.js
+  internal/
+    capabilities.js
+    config.js
+    intrinsics.js
+    logging.js
+    modules.js
+    routes.js
+    services.js
+    shared.js
+    runtime-classic.js
+  bootstrap.manifest.json
+```
+
+The installed layout is staged under:
+
+```text
+lib/sloppy/bootstrap/sloppy/
+```
+
+## Current Surface
+
+- `index.js` re-exports the app-host facade, result helpers, problem detail defaults,
+  schema helpers, provider
+  facades, and core API namespaces.
+- `app.js` provides the bootstrap builder/app/module surface used by examples and tests:
+  `Sloppy.create()`, `Sloppy.createBuilder()`, `Sloppy.module(...)`, `Router.group(...)`,
+  route registration, middleware/filter registration, app-host CORS policy/preflight
+  handling, health/readiness/liveness/startup routes, management endpoints, route-only `app.useModule(...)`,
+  explicit controller mapping, group metadata, config/log/services/capabilities facades,
+  structural freeze behavior, and debug snapshots.
+- `internal/capabilities.js`, `internal/config.js`, `internal/logging.js`,
+  `internal/modules.js`, `internal/routes.js`, `internal/services.js`, and
+  `internal/shared.js` hold app-host implementation helpers. They are staged bootstrap
+  assets. Public imports should use `sloppy`.
+- `results.js` provides frozen result descriptor helpers. V8-gated runtime conversion is
+  handled by the engine/runtime bridge; response writing belongs to runtime conversion.
+- `app.js` owns `app.useErrors(...)` and `app.mapError(...)`; `problem-details.js`
+  keeps `ProblemDetails.defaults(...)` as the compatibility descriptor for safe
+  route-handler error responses.
+- `request-id.js` provides `RequestId.defaults(...)` middleware for app-host request
+  IDs, trusted incoming ID admission, and optional response headers.
+- `request-logging.js` provides `RequestLogging.defaults(...)` middleware that writes
+  one structured entry per completed app-host request through the configured logger.
+- `health.js` and `metrics.js` provide the first-party operations backend used by
+  `app.health()` and `app.management(...)`.
+- `redis.js` provides the first-party RESP2 Redis client, scripts, locks, bounded
+  pooling, metrics, diagnostics, and redaction over the Sloppy network bridge.
+- `cache.js` provides the Redis-backed cache provider used by `Cache.redis(...)`
+  and app-host cache services.
+- `schema.js` provides the current `Schema` validation metadata surface for
+  strings, numbers, integers, booleans, arrays, enums, literals, optional,
+  nullable, defaulted fields, object shapes, and request body validation
+  errors.
+- `testing.js` provides `TestHost`, `TestServices`, `Testing.createHost`, fake clock helpers,
+  and test data helpers. App-host mode dispatches in memory through route
+  handlers, middleware, results, CORS, health checks, and scoped services.
+  Artifact/package modes call the Sloppy CLI so requests enter the native
+  runtime path. `TestServices` exposes honest live PostgreSQL and SQL Server
+  helpers that return `SKIPPED` service metadata when the env var or native
+  bridge is unavailable. The dogfood proof in
+  `tests/bootstrap/test_prealpha_control_plane_dogfood.mjs` imports the
+  `examples/prealpha-control-plane` route modules through this host.
+- `testservices.js` provides experimental `TestServices`, the opt-in Docker-backed
+  PostgreSQL, SQL Server, and Redis test service layer. It uses `sloppy/os` process
+  APIs for Docker CLI lifecycle, `sloppy/data` provider bridges or the Redis client
+  for readiness, and redacted diagnostics/cleanup for TestHost integration.
+- `http.js` provides the first-party outbound HTTP factory: named clients,
+  typed clients, resilience policies, service registration metadata, TestHost
+  mocks, metrics, diagnostics, and health snapshots over the low-level
+  `HttpClient` transport in `net.js`.
+- `webhooks.js` provides first-party webhook event descriptors, provider-backed
+  outbox SQL templates, subscription management, transactional publish, signed
+  delivery attempts, retry/dead-letter handling, inbound verification, and
+  TestHost-friendly receiver helpers.
+- `codec.js`, `crypto.js`, `fs.js`, `time.js`, `net.js`, `os.js`, and `workers.js` expose
+  the current public API shape and feature-gated bridge calls where native bridge support
+  exists.
+- `data.js` exposes query-template lowering, provider metadata helpers, and SQLite,
+  PostgreSQL, and SQL Server bridge entry points when the V8 lane installs the matching
+  provider bridge with Plan/capability metadata. SQL operation options accept `signal`,
+  `deadline`, and `timeoutMs` for Slop-side pre-dispatch cancellation/deadline checks.
+- `orm.js` exposes the first-party table/column DSL, schemas, CRUD helpers,
+  query builder, relation includes, migration snapshot/diff helpers, raw SQL
+  escape hatch, cursor adapter, and ORM error classes. Public imports should
+  use `sloppy/orm`.
+- `internal/runtime-classic.js` is the V8-gated classic-script runtime asset loaded before
+  generated artifacts. Generated code reads `globalThis.__sloppy_runtime` and registers
+  handlers through Sloppy-owned intrinsics. The embedded ORM runtime is generated
+  from `schema.js` and `orm.js` by `tools/scripts/sync-orm-runtime-classic.mjs`.
+
+## Boundaries
+
+- The bootstrap stdlib is JavaScript source staged with the runtime.
+- Source examples may use relative imports into this directory when they are API-shape
+  fixtures; compiler-owned runnable examples use the supported bare `"sloppy"` input shape.
+- Feature-gated APIs fail closed when the active runtime bridge is unavailable.
+- SQL operation cancellation/deadline options are Slop-side admission checks unless a
+  provider-specific lane separately documents and tests active native interruption.
+- Native handles and raw pointers are not exposed to JavaScript. Resource-backed bridge
+  facades use opaque Sloppy-owned objects, not public slot/generation fields.
+- Node compatibility is limited to explicit `sloppy/node/*` shim modules staged by
+  the dependency-loader path. Bun, Deno, browser Web API compatibility, full npm
+  ecosystem parity, and runtime package-manager behavior remain separate work.
+- Benchmark and release readiness are covered by dedicated docs and gates.
+
+## Future Work
+
+- `app.run`, `app.listen`, and `app.build` belong to later app lifecycle work.
+- Public handler registration APIs will be documented when the runtime support lands.
+- Full compiler extraction and arbitrary import rewriting beyond the supported
+  Sloppy/package resolver subset are compiler/runtime work.
+- Native plugins and full app lifecycle integration are planned separately.
+- Config file/environment/CLI loading inside the JS stdlib itself, secret managers,
+  tracing exporters, async service factories, and native service graph
+  validation belong to later framework/runtime slices. Native console and JSONL file
+  logging sinks are owned by the C runtime and configured through Plan/config metadata.
+
+## Source Docs
+
+- `docs/api/index.md`
+- `docs/api/testhost.md` — `TestHost`
+- `docs/api/testservices.md` — `TestServices`
+- `docs/api/orm.md` — `sloppy/orm`
+- `docs/reference/orm.md` — ORM reference
+- `docs/internals/orm-runtime.md` — ORM runtime embedding and compiler Plan metadata
+- `docs/api/filesystem.md` — `sloppy/fs`
+- `docs/api/network.md` — `sloppy/net`
+- `docs/api/http-client.md` — `Http` and `HttpClient`
+- `docs/reference/http-client.md` — HTTP factory reference
+- `docs/internals/http-client-runtime.md` — HTTP client runtime architecture
+- `docs/api/os.md` — `sloppy/os`
+- `docs/api/time.md` — `sloppy/time`
+- `docs/api/crypto.md` — `sloppy/crypto`
+- `docs/api/codec.md` — `sloppy/codec`
+- `docs/api/redis.md` — `Redis`
+- `docs/api/cache.md` — `Cache.redis`
+- `docs/api/workers.md` — `sloppy/workers`
+- `docs/contributor/js-ts-standards.md`
+- `docs/reference/supported-syntax.md`
+- `docs/reference/providers.md`
+- `docs/internals/security-model.md`
+- `docs/internals/runtime.md`