@presolve/framework 0.2.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2026 Presolve contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,22 @@
+# Presolve
+
+`@presolve/framework` is the public TypeScript authoring vocabulary for
+Presolve applications. Generated projects install it under the local
+`presolve` alias, preserving the canonical authoring import while using a
+registry-safe scoped package identity. It supplies inert compiler intrinsics
+and TypeScript declarations; the Presolve compiler is the sole authority that
+gives those forms semantic meaning.
+
+```tsx
+import { action, state, Component } from "presolve";
+
+export class Counter extends Component {
+  count = state(0);
+
+  increment = action(() => { this.count++; });
+
+  render() { return <button onClick={this.increment}>{this.count}</button>; }
+}
+```
+
+Install `@presolve/cli` as a development dependency to build an application.

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@presolve/framework",
+  "version": "0.2.0-beta.1",
+  "description": "Presolve compiler authoring vocabulary for TypeScript.",
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fierstdev/presolve.git",
+    "directory": "framework/packages/presolve"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "beta"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "default": "./src/index.js"
+    }
+  },
+  "scripts": {
+    "test": "node --input-type=module -e \"import('./src/index.js').then(({state}) => { if (state(1) !== 1) throw new Error('state intrinsic must be inert'); })\""
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,101 @@
+/** Compiler intrinsics with no framework runtime authority. */
+export type PresolveClassDecorator = <TClass extends abstract new (...args: never[]) => object>(
+  value: TClass,
+  context: ClassDecoratorContext<TClass>
+) => TClass | void;
+export type PresolveMethodDecorator = <
+  This,
+  Value extends (this: This, ...args: any[]) => unknown,
+>(
+  value: Value,
+  context: ClassMethodDecoratorContext<This, Value>
+) => Value | void;
+export type PresolveGetterDecorator = <This, Value>(
+  value: (this: This) => Value,
+  context: ClassGetterDecoratorContext<This, Value>
+) => ((this: This) => Value) | void;
+export type PresolveFieldDecorator = <This, Value>(
+  value: undefined,
+  context: ClassFieldDecoratorContext<This, Value>
+) => void;
+
+/** @deprecated Alpha compatibility decorator. V2 components extend `Component`. */
+export declare function component(): PresolveClassDecorator;
+/**
+ * Creates a V2 action instance field.  The overload without a handler is
+ * retained solely for alpha decorator compatibility.
+ */
+export declare function action<This, Args extends readonly unknown[], Value>(
+  handler: (this: This, ...args: Args) => Value
+): (this: This, ...args: Args) => Value;
+/** @deprecated Alpha compatibility decorator. */
+export declare function action(): PresolveMethodDecorator;
+export declare function computed(): PresolveGetterDecorator;
+/** Creates a V2 browser effect instance field. */
+export declare function effect<This>(
+  handler: (this: This) => void | (() => void)
+): void;
+/** @deprecated Alpha compatibility decorator. */
+export declare function effect(): PresolveMethodDecorator;
+export declare function state<T>(initialValue: T): T;
+
+/**
+ * Manifest-backed browser environment access for decorator-free V2 source.
+ * Values are admitted only when a matching compiler environment manifest
+ * classifies the requested name as `PRESOLVE_PUBLIC_*`.
+ */
+export declare const environment: {
+  public(name: string): string;
+};
+
+export declare function slot(): PresolveFieldDecorator;
+export interface SlotContent {
+  readonly __presolveSlotContentBrand: unique symbol;
+}
+
+export declare function context(): PresolveFieldDecorator;
+export type ContextDesignator = `${string}.${string}`;
+export declare function provide(context: ContextDesignator): PresolveFieldDecorator;
+export declare function consume(context: ContextDesignator): PresolveFieldDecorator;
+
+export declare function form(): PresolveFieldDecorator;
+/** A compiler-owned Form declaration marker; it is not a runtime controller. */
+export interface Form {
+  readonly __presolveFormBrand: unique symbol;
+}
+export declare function serialize(
+  format: "json" | "form-data" | "url-encoded"
+): PresolveFieldDecorator;
+export declare function field(form: string, path?: string): PresolveFieldDecorator;
+export interface ValidationRule {
+  readonly __presolveValidationRuleBrand: unique symbol;
+}
+export declare function validate(rule: ValidationRule): PresolveFieldDecorator;
+export declare function required(): ValidationRule;
+export declare function submit(form: string): PresolveMethodDecorator;
+
+export type ResourceState = "idle" | "pending" | "ready" | "failed" | "cancelled";
+export interface Resource<Data, Error> {
+  readonly data: Data | null;
+  readonly error: Error | null;
+  readonly state: ResourceState;
+  readonly __presolveResourceBrand: unique symbol;
+}
+export declare function resource(endpoint: string): PresolveFieldDecorator;
+export declare function loader(endpoint: string): PresolveFieldDecorator;
+export declare function serverAction(endpoint: string): PresolveMethodDecorator;
+export declare function opaque(
+  packageSpecifier: string,
+  exportName: string
+): PresolveMethodDecorator;
+
+export declare abstract class Component<Props = {}> {}
+
+declare global {
+  namespace JSX {
+    type Element = unknown;
+    interface IntrinsicElements {
+      [elementName: string]: unknown;
+    }
+  }
+}

package/src/index.js

@@ -0,0 +1,25 @@
+/** Compiler intrinsics: these declarations deliberately have no runtime authority. */
+const identityClass = (value) => value;
+const emptyField = () => undefined;
+
+export class Component {}
+
+export function component() { return identityClass; }
+export function action() { return identityClass; }
+export function computed() { return identityClass; }
+export function effect() { return identityClass; }
+export function state(value) { return value; }
+export function slot() { return emptyField; }
+export function context() { return emptyField; }
+export function provide() { return emptyField; }
+export function consume() { return emptyField; }
+export function form() { return emptyField; }
+export function serialize() { return emptyField; }
+export function field() { return emptyField; }
+export function validate() { return emptyField; }
+export function required() { return Object.freeze({}); }
+export function submit() { return identityClass; }
+export function resource() { return emptyField; }
+export function loader() { return emptyField; }
+export function serverAction() { return identityClass; }
+export function opaque() { return identityClass; }