@cimplify/sdk 0.108.0 → 0.110.2

package/dist/interactives-production.d.mts

@@ -0,0 +1,430 @@
+import { w as UiBinding, j as CrowdDoc, q as MusicBed } from './crowd-hOVSAmA3.mjs';
+import { q as Thing, H as WorldDoc } from './types-BQkxPwZP.mjs';
+import { L as LuaState, a as LuaValue, S as ScriptEvaluator, M as ModuleFactory } from './fallback-CrG_lTFk.mjs';
+import './clock-B-UAjkKa.mjs';
+import './ui-DwHicuFv.mjs';
+import './vars-Dc_PrhBK.mjs';
+import './audio-DhvyjqdA.mjs';
+import './backend-gUCzs5Kg.mjs';
+import './world-qekkXjJv.mjs';
+import './library-DXYaMFhi.mjs';
+
+type FieldLimit = null | {
+    readonly kind: "one_of";
+    readonly names: readonly string[];
+} | {
+    readonly kind: "codes";
+    readonly names: readonly string[];
+} | {
+    readonly kind: "positive";
+} | {
+    readonly kind: "non_negative";
+} | {
+    readonly kind: "range";
+    readonly min: number;
+    readonly max: number;
+} | {
+    readonly kind: "items";
+    readonly max: number;
+};
+interface FieldSpec {
+    readonly key: number;
+    readonly name: string;
+    readonly type: string;
+    readonly limit: FieldLimit;
+}
+interface KindSpec {
+    readonly code: number;
+    readonly name: string;
+    readonly parents: readonly string[];
+    readonly document: boolean;
+    readonly fields: readonly FieldSpec[];
+}
+declare class ProductionKindsError extends Error {
+    constructor(message: string);
+}
+declare class ProductionKinds {
+    readonly list: readonly KindSpec[];
+    private readonly byName;
+    private constructor();
+    static parse(json: string): ProductionKinds;
+    get names(): readonly string[];
+    get editable(): readonly string[];
+    has(name: unknown): name is string;
+    kind(name: string): KindSpec | null;
+    field(kind: string, name: string): FieldSpec | null;
+    fieldByKey(kind: string, key: number): FieldSpec | null;
+    parentAllowed(kind: string, parent: string): boolean;
+}
+
+type JsonValue = string | number | boolean | null | readonly JsonValue[];
+interface NodeJson {
+    readonly id: string;
+    readonly kind: string;
+    readonly fields: {
+        readonly [name: string]: JsonValue;
+    };
+    readonly children?: readonly NodeJson[];
+}
+interface SourceNode {
+    readonly id: bigint;
+    readonly kind: string;
+    readonly parent: bigint;
+    readonly order: readonly number[];
+    readonly fields: {
+        readonly [name: string]: JsonValue;
+    };
+    readonly children: readonly bigint[];
+}
+declare class ProductionSourceError extends Error {
+    constructor(message: string);
+}
+declare function idText(id: bigint): string;
+declare class ProductionSource {
+    private readonly byId;
+    readonly root: bigint;
+    private constructor();
+    static parse(json: string): ProductionSource;
+    get size(): number;
+    get(id: bigint): SourceNode | null;
+    children(parent: bigint): readonly bigint[];
+    field(id: bigint, name: string): JsonValue | null;
+    isWithin(id: bigint, ancestor: bigint): boolean;
+    json(id?: bigint, depth?: number): NodeJson | null;
+}
+
+declare class ProductionEditError extends Error {
+    constructor(message: string);
+}
+interface IdSource {
+    newId(): bigint;
+}
+interface Place {
+    readonly after?: bigint | null;
+    readonly before?: bigint | null;
+}
+interface ValueJson {
+    readonly type: string;
+    readonly value: JsonValue;
+}
+type ProductionChange = {
+    readonly op: "create";
+    readonly id: string;
+    readonly kind: string;
+    readonly parent: string;
+    readonly after?: string;
+    readonly before?: string;
+} | {
+    readonly op: "set";
+    readonly id: string;
+    readonly field: number;
+    readonly value: ValueJson | null;
+} | {
+    readonly op: "move";
+    readonly id: string;
+    readonly parent: string;
+    readonly after?: string;
+    readonly before?: string;
+} | {
+    readonly op: "delete";
+    readonly id: string;
+};
+declare function parseId(value: unknown): bigint;
+declare function valueFor(kinds: ProductionKinds, kind: string, field: string, value: JsonValue): ValueJson;
+declare class ProductionEdit {
+    private readonly source;
+    private readonly kinds;
+    private readonly ids;
+    private readonly list;
+    private readonly placed;
+    private readonly removed;
+    constructor(source: ProductionSource, kinds: ProductionKinds, ids: IdSource);
+    get changes(): readonly ProductionChange[];
+    get size(): number;
+    kindOf(id: bigint): string | null;
+    private parentOf;
+    private exists;
+    private within;
+    private checkParent;
+    private sibling;
+    private placement;
+    create(kind: string, parent: bigint, fields?: {
+        readonly [name: string]: JsonValue;
+    }, place?: Place, named?: bigint | null): bigint;
+    set(id: bigint, field: string, value: JsonValue | null): void;
+    move(id: bigint, parent: bigint, place?: Place): void;
+    remove(id: bigint): void;
+}
+
+type OriginName = "person" | "reesa" | "plugin" | "remix" | "system";
+interface CompiledDraft {
+    readonly program: Uint8Array;
+    readonly diagnostics: readonly unknown[];
+}
+interface ProductionCoreLike {
+    kinds(): string;
+}
+interface ProductionDraftLike {
+    sourceJson(): string;
+    editJson(author: number, origin: OriginName, changes: string): void;
+    newId(author: number): bigint;
+    undo(author: number): boolean;
+    redo(author: number): boolean;
+    compile(): CompiledDraft;
+    rulesCode?(): string;
+    applyRulesCode?(author: number, origin: OriginName, code: string): number;
+}
+declare class ProductionRulesUnavailableError extends Error {
+    readonly name = "ProductionRulesUnavailableError";
+    constructor();
+}
+interface CompileReport {
+    readonly bytes: number;
+    readonly diagnostics: number;
+}
+interface ProductionTarget {
+    readonly kinds: ProductionKinds;
+    sourceJson(): string;
+    editJson(author: number, origin: OriginName, changes: string): void;
+    newId(author: number): bigint;
+    undo(author: number): boolean;
+    redo(author: number): boolean;
+    compile(): CompileReport;
+    rulesCode(): string;
+    applyRulesCode(author: number, origin: OriginName, code: string): number;
+}
+declare function productionKinds(core: ProductionCoreLike): ProductionKinds;
+declare function productionTarget(core: ProductionCoreLike, draft: ProductionDraftLike): ProductionTarget;
+
+declare const EVERY_KIND = "every";
+interface OperationLimits {
+    readonly origin: OriginName;
+    readonly kinds: readonly string[] | typeof EVERY_KIND;
+    readonly fields: {
+        readonly [kind: string]: readonly string[] | undefined;
+    };
+    readonly create: boolean;
+    readonly remove: boolean;
+    readonly move: boolean;
+    readonly maxChanges: number;
+    readonly maxCreates: number;
+    readonly maxTextBytes: number;
+    readonly root?: boolean;
+}
+interface LimitRefusal {
+    readonly index: number;
+    readonly reason: string;
+}
+declare const PLUGIN_LIMITS: OperationLimits;
+declare const OUTSIDE_AGENT_LIMITS: OperationLimits;
+declare const PERSON_LIMITS: OperationLimits;
+declare const READ_ONLY_LIMITS: OperationLimits;
+declare function narrowLimits(base: OperationLimits, granted: Partial<Omit<OperationLimits, "origin">>): OperationLimits;
+declare function checkLimits(changes: readonly ProductionChange[], limits: OperationLimits, kinds: ProductionKinds, kindOf: (id: string) => string | null): LimitRefusal[];
+
+type NodeRef = string | number;
+type OperationRequest = {
+    readonly op: "create";
+    readonly kind: string;
+    readonly id?: NodeRef;
+    readonly parent?: NodeRef;
+    readonly after?: NodeRef;
+    readonly before?: NodeRef;
+    readonly fields?: {
+        readonly [name: string]: JsonValue;
+    };
+} | {
+    readonly op: "set";
+    readonly id: NodeRef;
+    readonly field: string;
+    readonly value: JsonValue | null;
+} | {
+    readonly op: "move";
+    readonly id: NodeRef;
+    readonly parent: NodeRef;
+    readonly after?: NodeRef;
+    readonly before?: NodeRef;
+} | {
+    readonly op: "remove";
+    readonly id: NodeRef;
+};
+type OperationResult = {
+    readonly ok: true;
+    readonly created: readonly string[];
+    readonly changes: number;
+} | {
+    readonly ok: false;
+    readonly refusals: readonly LimitRefusal[];
+};
+declare const NEW_REF_PREFIX = "$";
+declare class ProductionOperations {
+    private readonly target;
+    readonly author: number;
+    readonly limits: OperationLimits;
+    constructor(target: ProductionTarget, author: number, limits: OperationLimits);
+    get kinds(): ProductionKinds;
+    snapshot(): ProductionSource;
+    read(id?: NodeRef | null, depth?: number): NodeJson | null;
+    apply(requests: readonly OperationRequest[]): OperationResult;
+    undo(): boolean;
+    redo(): boolean;
+    compile(): CompileReport;
+}
+
+interface NodeSpec {
+    readonly kind: string;
+    readonly fields: {
+        readonly [name: string]: JsonValue;
+    };
+    readonly children: readonly NodeSpec[];
+}
+declare const THING_KIND = "thing";
+declare const WORLD_KIND = "world";
+declare const BINDING_KIND = "binding";
+declare const MUSIC_KIND = "music";
+declare const CROWD_KIND = "crowd";
+declare function thingSpec(thing: Thing): NodeSpec;
+declare function thingOf(spec: NodeSpec): Thing;
+declare function worldSpec(world: WorldDoc): NodeSpec;
+declare function worldOf(spec: NodeSpec): WorldDoc;
+declare function bindingSpec(name: string, binding: UiBinding): NodeSpec;
+declare function bindingOf(spec: NodeSpec): {
+    readonly name: string;
+    readonly binding: UiBinding;
+};
+declare function musicSpec(music: MusicBed): NodeSpec;
+declare function musicOf(spec: NodeSpec): MusicBed;
+declare function crowdSpec(crowd: CrowdDoc): NodeSpec;
+declare function crowdOf(spec: NodeSpec): CrowdDoc;
+declare function specAt(source: ProductionSource, id: bigint): NodeSpec | null;
+declare function documentsOf(source: ProductionSource, kind: string): {
+    readonly id: string;
+    readonly spec: NodeSpec;
+}[];
+/**
+ * The requests that make the document `id` hold `spec`: its creation (with every child) when it does not exist yet,
+ * otherwise each changed or cleared field, and its children rewritten when they differ. Created nodes take ids from
+ * `newId`, so the caller can name them before the edit lands.
+ */
+declare function documentRequests(source: ProductionSource, id: string, spec: NodeSpec, newId: () => string): OperationRequest[];
+
+declare const PLUGIN_CALLS: readonly ["kinds", "read", "edit", "undo", "redo"];
+type PluginCall = (typeof PLUGIN_CALLS)[number];
+interface PluginGrant {
+    readonly kinds?: readonly string[];
+    readonly fields?: {
+        readonly [kind: string]: readonly string[] | undefined;
+    };
+    readonly create?: boolean;
+    readonly remove?: boolean;
+    readonly move?: boolean;
+}
+interface PluginManifest {
+    readonly id: string;
+    readonly name: string;
+    readonly version: string;
+    readonly grant: PluginGrant;
+}
+interface PluginRequest {
+    readonly id: number;
+    readonly call: string;
+    readonly args?: {
+        readonly [key: string]: unknown;
+    };
+}
+type PluginReply = {
+    readonly id: number;
+    readonly ok: true;
+    readonly result: unknown;
+} | {
+    readonly id: number;
+    readonly ok: false;
+    readonly error: string;
+};
+declare const PLUGIN_CALLS_PER_SECOND = 30;
+declare const PLUGIN_EDITS_PER_SECOND = 10;
+declare class PluginManifestError extends Error {
+    constructor(message: string);
+}
+declare function parsePluginManifest(value: unknown, known: ProductionKinds): PluginManifest;
+declare function pluginLimits(manifest: PluginManifest): OperationLimits;
+declare class PluginSession {
+    readonly manifest: PluginManifest;
+    readonly operations: ProductionOperations;
+    private windowStart;
+    private calls;
+    private edits;
+    constructor(target: ProductionTarget, author: number, manifest: PluginManifest);
+    handle(request: PluginRequest, nowMs: number): PluginReply;
+}
+
+declare const PLUGIN_GLOBAL = "production";
+declare const MAX_PLUGIN_DEPTH = 16;
+type Plain = string | number | boolean | null | readonly Plain[] | {
+    readonly [key: string]: Plain;
+};
+declare function tableToPlain(value: LuaValue, depth?: number): Plain;
+declare function plainToTable(value: unknown, depth?: number): LuaValue;
+declare function openProductionApi(state: LuaState, session: PluginSession, now: () => number): void;
+
+declare const PLUGIN_CHUNK = "plugin";
+declare const DEFAULT_PLUGIN_BUDGET = 5000000;
+declare const PLUGIN_BUDGET_MESSAGE = "the tool took too long and was stopped";
+declare const SINGLE_OPERATION = "run";
+type PluginLoader = (bytecode: Uint8Array) => Promise<ModuleFactory>;
+interface OpenProductionPlugin {
+    readonly bytecode: Uint8Array;
+    readonly manifest: PluginManifest;
+    readonly target: ProductionTarget;
+    readonly author: number;
+    readonly now?: () => number;
+    readonly seed?: number;
+    readonly budget?: number;
+    readonly evaluate?: ScriptEvaluator;
+    readonly load?: PluginLoader;
+}
+type PluginRun = {
+    readonly ok: true;
+    readonly result: unknown;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+declare class PluginLoadError extends Error {
+    constructor(message: string);
+}
+/**
+ * A Luau plugin running on a draft through the operation API. Its chunk returns a table of operations; each runs in the
+ * sandboxed, budgeted VM with the `production` table limited to the manifest's grant, and every edit it makes is one
+ * undoable step stamped as a plugin's.
+ */
+declare class ProductionPlugin {
+    private readonly state;
+    private readonly table;
+    readonly session: PluginSession;
+    private readonly budget;
+    readonly operations: readonly string[];
+    private constructor();
+    static open(options: OpenProductionPlugin): Promise<ProductionPlugin>;
+    run(name: string, input?: unknown): PluginRun;
+    private static message;
+}
+declare function openProductionPlugin(options: OpenProductionPlugin): Promise<ProductionPlugin>;
+
+type ToolSchema = {
+    readonly [key: string]: unknown;
+};
+interface OperationTool {
+    readonly name: string;
+    readonly title: string;
+    readonly description: string;
+    readonly inputSchema: ToolSchema;
+    readonly readOnly: boolean;
+    run(args: {
+        readonly [key: string]: unknown;
+    }): unknown;
+}
+declare function describeKinds(kinds: ProductionKinds): unknown;
+declare function productionTools(operations: ProductionOperations): OperationTool[];
+
+export { BINDING_KIND, CROWD_KIND, type CompileReport, type CompiledDraft, DEFAULT_PLUGIN_BUDGET, EVERY_KIND, type FieldLimit, type FieldSpec, type IdSource, type JsonValue, type KindSpec, type LimitRefusal, MAX_PLUGIN_DEPTH, MUSIC_KIND, NEW_REF_PREFIX, type NodeJson, type NodeRef, type NodeSpec, OUTSIDE_AGENT_LIMITS, type OpenProductionPlugin, type OperationLimits, type OperationRequest, type OperationResult, type OperationTool, type OriginName, PERSON_LIMITS, PLUGIN_BUDGET_MESSAGE, PLUGIN_CALLS, PLUGIN_CALLS_PER_SECOND, PLUGIN_CHUNK, PLUGIN_EDITS_PER_SECOND, PLUGIN_GLOBAL, PLUGIN_LIMITS, type Place, type PluginCall, type PluginGrant, PluginLoadError, type PluginLoader, type PluginManifest, PluginManifestError, type PluginReply, type PluginRequest, type PluginRun, PluginSession, type ProductionChange, type ProductionCoreLike, type ProductionDraftLike, ProductionEdit, ProductionEditError, ProductionKinds, ProductionKindsError, ProductionOperations, ProductionPlugin, ProductionRulesUnavailableError, ProductionSource, ProductionSourceError, type ProductionTarget, READ_ONLY_LIMITS, SINGLE_OPERATION, type SourceNode, THING_KIND, type ToolSchema, type ValueJson, WORLD_KIND, bindingOf, bindingSpec, checkLimits, crowdOf, crowdSpec, describeKinds, documentRequests, documentsOf, idText, musicOf, musicSpec, narrowLimits, openProductionApi, openProductionPlugin, parseId, parsePluginManifest, plainToTable, pluginLimits, productionKinds, productionTarget, productionTools, specAt, tableToPlain, thingOf, thingSpec, valueFor, worldOf, worldSpec };