@poe-platform/safe-js 0.1.0

package/dist/toolcraft-schema/index.d.ts

@@ -0,0 +1,184 @@
+import { Json } from "./json.js";
+import { OneOf } from "./oneof.js";
+import { Record as RecordBuilder } from "./record.js";
+import { Union } from "./union.js";
+import { validate } from "./validate.js";
+import type { JsonValue, JsonValueSchema } from "./json.js";
+import type { JsonSchemaDocument, JsonSchemaDocumentOptions } from "./json-schema-document.js";
+import type { OneOfSchema } from "./oneof.js";
+import type { RecordSchema } from "./record.js";
+import type { UnionSchema } from "./union.js";
+import type { ValidationIssue, ValidationResult } from "./validate.js";
+type JsonSchemaType = "string" | "number" | "integer" | "boolean" | "array" | "object";
+type SchemaKind = "string" | "number" | "boolean" | "enum" | "array" | "object" | "optional" | "oneOf" | "union" | "record" | "json";
+type EnumValue = string | number | boolean;
+type JsonSchemaEnumValue = EnumValue | null;
+type NumberJsonType = "number" | "integer";
+type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
+type ObjectShape = Record<string, AnySchema>;
+type EmptyOptions = Record<never, never>;
+type SchemaScope = "cli" | "mcp" | "sdk";
+export type CliOutputMode = "rich" | "md" | "json";
+export interface CliMissingParameterChoice<TValue> {
+    label: string;
+    value: TValue;
+}
+export interface CliMissingParameterContext {
+    commandPath: string;
+    params: Readonly<Record<string, unknown>>;
+    output: CliOutputMode;
+    stdinTTY: boolean;
+    stdoutTTY: boolean;
+}
+export interface CliMissingParameterResolution<TValue> {
+    choices: readonly CliMissingParameterChoice<TValue>[];
+    message?: string;
+}
+export interface CliSchemaOptions<TValue> {
+    resolveMissing?: (context: CliMissingParameterContext) => CliMissingParameterResolution<TValue> | undefined | Promise<CliMissingParameterResolution<TValue> | undefined>;
+}
+type StringMetadata = {
+    format?: string;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    secret?: boolean;
+};
+type NumberMetadata = {
+    maximum?: number;
+    minimum?: number;
+    secret?: boolean;
+};
+type ArrayMetadata = {
+    maxItems?: number;
+    minItems?: number;
+};
+type ObjectMetadata = {
+    additionalProperties?: boolean;
+};
+type OptionalKeys<TShape extends ObjectShape> = {
+    [TKey in keyof TShape]: TShape[TKey] extends OptionalSchema<any> ? TKey : never;
+}[keyof TShape];
+type RequiredKeys<TShape extends ObjectShape> = Exclude<keyof TShape, OptionalKeys<TShape>>;
+type PropertyStatic<TSchema extends AnySchema> = TSchema extends OptionalSchema<infer TInner> ? Static<TInner> : Static<TSchema>;
+type InferObject<TShape extends ObjectShape> = {
+    [TKey in RequiredKeys<TShape>]: PropertyStatic<TShape[TKey]>;
+} & {
+    [TKey in OptionalKeys<TShape>]?: PropertyStatic<TShape[TKey]>;
+};
+type SchemaOptions<TDefault> = {
+    cli?: CliSchemaOptions<TDefault>;
+    description?: string;
+    cliDescription?: string;
+    cliAliases?: readonly string[];
+    default?: TDefault;
+    nullable?: boolean;
+    requiredScopes?: readonly SchemaScope[];
+    short?: string;
+    scope?: readonly SchemaScope[];
+    global?: boolean;
+};
+type WithNullable<TSchema extends AnySchema, TOptions extends {
+    nullable?: boolean;
+}> = TOptions extends {
+    readonly nullable: true;
+} ? TSchema & {
+    readonly nullable: true;
+} : TSchema;
+export interface SchemaBase<TKind extends SchemaKind, TStatic> {
+    readonly kind: TKind;
+    readonly cli?: CliSchemaOptions<TStatic>;
+    readonly description?: string;
+    readonly cliDescription?: string;
+    readonly cliAliases?: readonly string[];
+    readonly default?: TStatic;
+    readonly nullable?: boolean;
+    readonly requiredScopes?: readonly SchemaScope[];
+    readonly short?: string;
+    readonly scope?: readonly SchemaScope[];
+    readonly global?: boolean;
+    readonly __static?: TStatic;
+}
+export interface JsonSchema {
+    additionalProperties?: boolean | JsonSchema;
+    type?: JsonSchemaType;
+    description?: string;
+    default?: unknown;
+    enum?: ReadonlyArray<JsonSchemaEnumValue>;
+    format?: string;
+    items?: JsonSchema;
+    maxItems?: number;
+    maximum?: number;
+    maxLength?: number;
+    minItems?: number;
+    minimum?: number;
+    minLength?: number;
+    nullable?: boolean;
+    oneOf?: JsonSchema[];
+    pattern?: string;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+}
+export interface StringSchema extends SchemaBase<"string", string>, StringMetadata {
+}
+export interface NumberSchema extends SchemaBase<"number", number>, NumberMetadata {
+    readonly jsonType?: NumberJsonType;
+}
+export type BooleanSchema = SchemaBase<"boolean", boolean>;
+export interface EnumSchema<TValues extends NonEmptyReadonlyArray<EnumValue>> extends SchemaBase<"enum", TValues[number]> {
+    readonly values: TValues;
+    readonly jsonType?: "integer";
+    readonly labels?: Partial<Record<string, string>>;
+    readonly loadOptions?: (() => Array<{
+        label: string;
+        value: string;
+    }>) | (() => Promise<Array<{
+        label: string;
+        value: string;
+    }>>);
+}
+export interface ArraySchema<TItem extends AnySchema> extends SchemaBase<"array", Array<Static<TItem>>>, ArrayMetadata {
+    readonly item: TItem;
+}
+export interface ObjectSchema<TShape extends ObjectShape> extends SchemaBase<"object", InferObject<TShape>>, ObjectMetadata {
+    readonly shape: TShape;
+}
+export interface OptionalSchema<TInner extends AnySchema> extends SchemaBase<"optional", Static<TInner> | undefined> {
+    readonly inner: TInner;
+}
+export type AnySchema = StringSchema | NumberSchema | BooleanSchema | EnumSchema<NonEmptyReadonlyArray<EnumValue>> | ArraySchema<AnySchema> | ObjectSchema<ObjectShape> | OptionalSchema<AnySchema> | OneOfSchema<Record<string, ObjectSchema<any>>, string> | UnionSchema<readonly ObjectSchema<any>[]> | RecordSchema<AnySchema> | JsonValueSchema;
+export type Static<TSchema extends AnySchema> = TSchema extends {
+    readonly nullable: true;
+} ? TSchema extends SchemaBase<any, infer TStatic> ? TStatic | null : never : TSchema extends SchemaBase<any, infer TStatic> ? TStatic : never;
+export declare const S: {
+    readonly String: <const TOptions extends SchemaOptions<string> & StringMetadata = EmptyOptions>(options?: TOptions) => WithNullable<StringSchema, TOptions>;
+    readonly Number: <const TOptions extends SchemaOptions<number> & NumberMetadata & {
+        jsonType?: NumberJsonType;
+    } = EmptyOptions>(options?: TOptions) => WithNullable<NumberSchema, TOptions>;
+    readonly Boolean: <const TOptions extends SchemaOptions<boolean> = EmptyOptions>(options?: TOptions) => WithNullable<BooleanSchema, TOptions>;
+    readonly Enum: <const TValues extends NonEmptyReadonlyArray<EnumValue>, const TOptions extends SchemaOptions<TValues[number]> & {
+        jsonType?: "integer";
+        labels?: Partial<Record<string, string>>;
+        loadOptions?: (() => Array<{
+            label: string;
+            value: string;
+        }>) | (() => Promise<Array<{
+            label: string;
+            value: string;
+        }>>);
+    } = EmptyOptions>(values: TValues, options?: TOptions) => WithNullable<EnumSchema<TValues>, TOptions>;
+    readonly Array: <TItem extends AnySchema, const TOptions extends SchemaOptions<Array<Static<TItem>>> & ArrayMetadata = EmptyOptions>(item: TItem, options?: TOptions) => WithNullable<ArraySchema<TItem>, TOptions>;
+    readonly Object: <const TShape extends ObjectShape, const TOptions extends SchemaOptions<InferObject<TShape>> & ObjectMetadata = EmptyOptions>(shape: TShape, options?: TOptions) => WithNullable<ObjectSchema<TShape>, TOptions>;
+    readonly Optional: <TInner extends AnySchema>(inner: TInner) => OptionalSchema<TInner>;
+    readonly OneOf: typeof OneOf;
+    readonly Union: typeof Union;
+    readonly Record: typeof RecordBuilder;
+    readonly Json: typeof Json;
+};
+export declare function toJsonSchema(schema: AnySchema): JsonSchema;
+export declare function toJsonSchemaDocument(schema: AnySchema, options?: JsonSchemaDocumentOptions): JsonSchemaDocument;
+export { Json, OneOf, RecordBuilder as Record, Union, validate };
+export { compileJsonSchema, formatIssues } from "./json-schema/index.js";
+export type { CompileJsonSchemaOptions, CompiledJsonSchema } from "./json-schema/index.js";
+export type { JsonSchemaDocument, JsonSchemaDocumentOptions } from "./json-schema-document.js";
+export type { JsonValue, JsonValueSchema, OneOfSchema, RecordSchema, UnionSchema, ValidationIssue, ValidationResult };

package/dist/toolcraft-schema/json-schema/index.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationIssue } from "../validate.js";
+import type { CompileJsonSchemaOptions, CompiledJsonSchema } from "./types.js";
+export type { CompileJsonSchemaOptions, CompiledJsonSchema } from "./types.js";
+export declare function compileJsonSchema(schema: unknown, options?: CompileJsonSchemaOptions): CompiledJsonSchema;
+export declare function formatIssues(issues: readonly ValidationIssue[]): string;

package/dist/toolcraft-schema/json-schema/types.d.ts

@@ -0,0 +1,33 @@
+import type { ValidationIssue, ValidationResult } from "../validate.js";
+export type JsonSchemaRegistry = Record<string, unknown>;
+export interface CompileJsonSchemaOptions {
+    registry?: JsonSchemaRegistry;
+}
+export interface CompiledJsonSchema {
+    validate(value: unknown): ValidationResult<unknown>;
+}
+export type Dialect = "draft7" | "draft2020-12";
+export type SchemaObject = Record<string, unknown>;
+export type JsonSchema = boolean | SchemaObject;
+export interface SchemaNode {
+    schema: JsonSchema;
+    documentId: string;
+    dialect: Dialect;
+    baseUri: string;
+    resourceUri: string;
+    resourceRoot: SchemaNode;
+    pointer: string;
+    validationVocabulary: boolean;
+    children: Map<string, SchemaNode>;
+}
+export interface EvaluationResult {
+    valid: boolean;
+    issues: ValidationIssue[];
+    evaluatedProperties: Set<string>;
+    evaluatedItems: Set<number>;
+}
+export interface EvaluationContext {
+    instancePath: readonly string[];
+    dynamicScope: readonly SchemaNode[];
+    activePairs: Map<SchemaNode, Set<unknown>>;
+}

package/dist/toolcraft-schema/json-schema-document.d.ts

@@ -0,0 +1,14 @@
+import type { JsonSchema } from "./index.js";
+export interface JsonSchemaDocumentOptions {
+    id?: string;
+    title?: string;
+    description?: string;
+    schema?: string;
+}
+export type JsonSchemaDocument = JsonSchema & {
+    $schema: string;
+    $id?: string;
+    title?: string;
+    description?: string;
+};
+export declare function createJsonSchemaDocument(jsonSchema: JsonSchema, options?: JsonSchemaDocumentOptions): JsonSchemaDocument;

package/dist/toolcraft-schema/json.d.ts

@@ -0,0 +1,10 @@
+import type { SchemaBase } from "./index.js";
+type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | {
+    [key: string]: JsonValue;
+} | JsonValue[];
+export interface JsonValueSchema extends SchemaBase<"json", JsonValue> {
+    readonly kind: "json";
+}
+export declare function Json(): JsonValueSchema;
+export {};

package/dist/toolcraft-schema/oneof.d.ts

@@ -0,0 +1,15 @@
+import type { ObjectSchema, SchemaBase, Static } from "./index.js";
+type OneOfStatic<TBranches extends Record<string, ObjectSchema<any>>, TDiscriminator extends string> = {
+    [TBranchName in keyof TBranches & string]: Omit<Static<TBranches[TBranchName]>, TDiscriminator> & {
+        [TFieldName in TDiscriminator]: TBranchName;
+    };
+}[keyof TBranches & string];
+export interface OneOfSchema<TBranches extends Record<string, ObjectSchema<any>>, TDiscriminator extends string = string> extends SchemaBase<"oneOf", OneOfStatic<TBranches, TDiscriminator>> {
+    readonly discriminator: TDiscriminator;
+    readonly branches: TBranches;
+}
+export declare function OneOf<TDiscriminator extends string, TBranches extends Record<string, ObjectSchema<any>>>(config: {
+    discriminator: TDiscriminator;
+    branches: TBranches;
+}): OneOfSchema<TBranches, TDiscriminator>;
+export {};

package/dist/toolcraft-schema/record.d.ts

@@ -0,0 +1,5 @@
+import type { AnySchema, SchemaBase, Static } from "./index.js";
+export interface RecordSchema<TValue extends AnySchema> extends SchemaBase<"record", Record<string, Static<TValue>>> {
+    readonly value: TValue;
+}
+export declare function Record<TValue extends AnySchema>(value: TValue): RecordSchema<TValue>;

package/dist/toolcraft-schema/union.d.ts

@@ -0,0 +1,8 @@
+import type { ObjectSchema, SchemaBase, Static } from "./index.js";
+type UnionStatic<TBranches extends readonly ObjectSchema<any>[]> = Static<TBranches[number]>;
+export interface UnionSchema<TBranches extends readonly ObjectSchema<any>[]> extends SchemaBase<"union", UnionStatic<TBranches>> {
+    readonly branches: TBranches;
+}
+export declare function getRequiredKeyFingerprint(schema: ObjectSchema<any>): string;
+export declare function Union<const TBranches extends readonly ObjectSchema<any>[]>(branches: TBranches): UnionSchema<TBranches>;
+export {};

package/dist/toolcraft-schema/validate.d.ts

@@ -0,0 +1,17 @@
+import type { AnySchema, Static } from "./index.js";
+export type SchemaDescriptor = AnySchema;
+export type ValidationIssue = {
+    path: readonly string[];
+    expected: string;
+    received: string;
+    message: string;
+    keyword?: string;
+};
+export type ValidationResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    issues: readonly ValidationIssue[];
+};
+export declare function validate<S extends SchemaDescriptor>(schema: S, value: unknown): ValidationResult<Static<S>>;

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@poe-platform/safe-js",
+  "version": "0.1.0",
+  "description": "Budgeted JavaScript interpreter with explicit host capabilities and resumable execution",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.18"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./fs": {
+      "types": {
+        "browser": "./dist/safe-fs/core.d.ts",
+        "default": "./dist/safe-fs/index.d.ts"
+      },
+      "browser": "./dist/safe-js/browser/safe-fs.js",
+      "import": "./dist/safe-js/safe-fs.js"
+    },
+    "./fs/core": {
+      "types": {
+        "browser": "./dist/safe-fs/core.d.ts",
+        "default": "./dist/safe-fs/core.d.ts"
+      },
+      "browser": "./dist/safe-js/browser/safe-fs-core.js",
+      "import": "./dist/safe-js/safe-fs-core.js"
+    },
+    "./fs/node": {
+      "types": {
+        "browser": "./dist/safe-fs/node-unavailable.d.ts",
+        "default": "./dist/safe-fs/node-host.d.ts"
+      },
+      "browser": null,
+      "import": "./dist/safe-js/safe-fs-node.js"
+    },
+    ".": {
+      "types": {
+        "browser": "./dist/safe-fs/node-unavailable.d.ts",
+        "default": "./dist/safe-js/index.d.ts"
+      },
+      "browser": null,
+      "import": "./dist/safe-js/index.js"
+    },
+    "./core": {
+      "types": {
+        "browser": "./dist/safe-fs/node-unavailable.d.ts",
+        "default": "./dist/safe-js/core.d.ts"
+      },
+      "browser": null,
+      "import": "./dist/safe-js/core.js"
+    },
+    "./cli": {
+      "types": {
+        "browser": "./dist/safe-fs/node-unavailable.d.ts",
+        "default": "./dist/safe-js/cli.d.ts"
+      },
+      "browser": null,
+      "import": "./dist/safe-js/cli.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/poe-platform/poe-code.git",
+    "directory": "packages/safe-js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "yaml": "^2.8.2",
+    "jose": "^6.1.3",
+    "@types/node": "^25.2.2"
+  },
+  "imports": {
+    "#safe-fs-platform": {
+      "types": {
+        "browser": "./dist/safe-fs/platform/browser.d.ts",
+        "default": "./dist/safe-fs/platform/node.d.ts"
+      },
+      "default": null
+    }
+  },
+  "bin": {
+    "poe-safejs": "./dist/safe-js/cli.js",
+    "poe-safe-js": "./dist/safe-js/cli.js"
+  }
+}