JavaScript Ontology

FLOW ALGEBRA
JavaScript Ontology
Kireth Semantic Research Archive

PAGE:
https://kirethresearch.org/booksai-core/ontologies/computing-ontologies/web-technologies/j-avascript-ontology.html

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "JavaScriptOntology" v4.0

# ---------- DOMAIN ----------
DOMAIN := ComputingOntology
SUBDOMAIN := WebTechnologies
ONTOLOGY := JavaScriptOntology

# ---------- PRIMARY ENTITY ----------
ENTITY JavaScript {
    definition:
        "A high-level programming language used to define executable logic,
         dynamic behaviour and asynchronous interaction in web browsers,
         servers and other computing environments.";

    objectives: [
        ProgramExecution,
        DynamicInteraction,
        EventHandling,
        DataProcessing,
        AsynchronousProgramming,
        WebApplicationBehaviour
    ];
}

# ---------- CORE ENTITIES ----------
JavaScriptEntity := {
    Program,
    Script,
    Statement,
    Expression,
    Variable,
    Value,
    Function,
    Object,
    Module
};

ValueType := {
    Undefined,
    Null,
    Boolean,
    Number,
    BigInt,
    String,
    Symbol,
    Object
};

ExecutionEntity := {
    ExecutionContext,
    CallStack,
    Scope,
    Environment,
    Job,
    Task,
    EventLoop
};

WebIntegrationEntity := {
    DOM,
    Event,
    WebAPI,
    NetworkRequest,
    Storage,
    Browser
};

# ---------- FUNDAMENTAL RELATIONSHIPS ----------
JavaScriptProgram CONSISTS_OF Statement;
Expression PRODUCES Value;
Variable REFERENCES Value;
Function CONTAINS ExecutableCode;
Function MAY_RECEIVE Argument;
Function MAY_RETURN Value;
Object HAS Property;
Browser MAY_EXECUTE JavaScriptProgram;
JavaScript MAY_INTERACT_WITH DOM;
JavaScript MAY_CALL WebAPI;

# ---------- PROGRAM EXECUTION ----------
SourceCode ->
    Parse
    -> CreateExecutableRepresentation
    -> EstablishExecutionContext
    -> ExecuteStatements
    -> EvaluateExpressions
    -> ProduceEffectsOrValues;

SyntaxError MAY_PREVENT SuccessfulExecution;

# ---------- STATEMENT ----------
Statement :=
    ExecutableOrControlConstruct;

Statement MAY_BE {
    Declaration,
    ExpressionStatement,
    Conditional,
    Loop,
    Return,
    Throw,
    Import,
    Export
};

# ---------- EXPRESSION ----------
Expression :=
    CodeThatEvaluatesToValue;

Expression MAY_INCLUDE {
    Literal,
    Identifier,
    OperatorExpression,
    FunctionCall,
    PropertyAccess,
    Assignment
};

# ---------- VARIABLE ----------
Variable :=
    NamedBindingWithinEnvironment;

DeclarationKind MAY_BE {
    let,
    const,
    var
};

Binding HAS ScopeAndValueState;

const PREVENTS ReassignmentOfBinding;
const DOES_NOT_IMPLY DeepObjectImmutability;

# ---------- PRIMITIVE VALUE ----------
PrimitiveValue := {
    Undefined,
    Null,
    Boolean,
    Number,
    BigInt,
    String,
    Symbol
};

ObjectValue IS_NON_PRIMITIVE;

# ---------- TYPE ----------
JavaScriptValue HAS RuntimeType;

typeof MAY_RETURN TypeClassification;

DynamicTyping :=
    VariableBinding MAY_REFERENCE ValuesOfDifferentTypesOverTime;

# ---------- OPERATOR ----------
Operator MAY_INCLUDE {
    ArithmeticOperator,
    ComparisonOperator,
    LogicalOperator,
    AssignmentOperator,
    ConditionalOperator
};

Operator APPLIES_TO Operand;

# ---------- CONTROL FLOW ----------
Conditional :=
    Condition
    -> BranchSelection
    -> ExecuteSelectedBranch;

IF ConditionTruthy
THEN ExecuteConsequent
ELSE ExecuteAlternative;

# ---------- LOOP ----------
Loop MAY_BE {
    for,
    while,
    do_while,
    for_of,
    for_in
};

Loop REPEATS ExecutionAccordingToConditionOrIterationSource;

# ---------- FUNCTION ----------
Function :=
    CallableObjectContainingExecutableCode;

Function MAY_HAVE {
    ParameterList,
    FunctionBody,
    ReturnValue,
    LexicalEnvironment
};

FunctionCall ->
    EvaluateCallee
    -> EvaluateArguments
    -> CreateExecutionContext
    -> ExecuteFunctionBody
    -> Return;

# ---------- ARROW FUNCTION ----------
ArrowFunction :=
    FunctionSyntaxWithLexicalThisBindingBehaviour;

ArrowFunction DOES_NOT_HAVE OwnThisBindingInSameWayAsOrdinaryFunction;

# ---------- SCOPE ----------
Scope :=
    RegionInWhichBindingIsAccessible;

ScopeType MAY_INCLUDE {
    GlobalScope,
    ModuleScope,
    FunctionScope,
    BlockScope
};

LexicalScoping DETERMINES IdentifierResolutionByProgramStructure;

# ---------- CLOSURE ----------
Closure :=
    Function
    + RetainedAccessToLexicalEnvironment;

Closure MAY_ACCESS OuterBindingsAfterOuterFunctionReturns;

# ---------- OBJECT ----------
Object :=
    CollectionOfPropertiesAndInternalBehaviour;

Property :=
    Key
    -> ValueOrAccessor;

Object MAY_INHERIT_FROM Prototype;

# ---------- PROTOTYPE ----------
Prototype :=
    ObjectUsedForPropertyInheritance;

PrototypeChain :=
    Object
    -> Prototype
    -> Prototype
    -> null;

PropertyLookup MAY_TRAVERSE PrototypeChain;

# ---------- CLASS ----------
ClassSyntax :=
    StructuredSyntaxForConstructorAndPrototypeBasedBehaviour;

Class MAY_DEFINE {
    Constructor,
    Method,
    Getter,
    Setter,
    Field
};

JavaScriptClass BUILDS_ON PrototypeMechanism;

# ---------- ARRAY ----------
Array :=
    IndexedObjectDesignedForOrderedValues;

Array MAY_HAVE {
    Length,
    IndexedElements,
    Methods
};

ArrayMethod MAY_INCLUDE {
    map,
    filter,
    reduce,
    find,
    forEach
};

# ---------- MODULE ----------
Module :=
    JavaScriptCodeWithExplicitImportsAndExports;

Module MAY_EXPORT Binding;
Module MAY_IMPORT Binding;

ModuleScope IS_DISTINCT_FROM ClassicGlobalScriptScope;

# ---------- EXCEPTION ----------
Exception :=
    AbnormalControlFlowRepresentedByThrownValue;

throw PRODUCES Exception;

try_catch MAY_HANDLE Exception;

UnhandledException MAY_TERMINATE CurrentExecutionPath;

# ---------- EVENT ----------
Event :=
    NotificationOfOccurrenceInHostEnvironment;

Event MAY_BE {
    ClickEvent,
    InputEvent,
    SubmitEvent,
    KeyboardEvent,
    NetworkEvent,
    TimerEvent
};

EventListener :=
    FunctionRegisteredForEvent;

IF EventOccurs
THEN RegisteredHandler MAY_BE ScheduledForExecution;

# ---------- DOM ----------
DOM :=
    ProgrammaticRepresentationOfWebDocument;

JavaScript MAY {
    QueryElement,
    CreateElement,
    RemoveElement,
    ModifyAttribute,
    ModifyText,
    AttachEventListener
};

DOMChange MAY_TRIGGER BrowserRenderingWork;

# ---------- ASYNCHRONOUS EXECUTION ----------
AsynchronousOperation :=
    OperationWhoseCompletionOccursLaterThanInitiation;

AsyncOperation MAY_INCLUDE {
    NetworkRequest,
    Timer,
    UserEvent,
    FileOrHostOperation
};

Completion MAY_SCHEDULE CallbackOrPromiseReaction;

# ---------- PROMISE ----------
Promise :=
    ObjectRepresentingFutureCompletionOrFailureOfOperation;

PromiseState := {
    Pending,
    Fulfilled,
    Rejected
};

Promise MAY_SETTLE_ONCE;

FulfilledPromise HAS FulfilmentValue;
RejectedPromise HAS RejectionReason;

# ---------- ASYNC / AWAIT ----------
AsyncFunction RETURNS Promise;

await :=
    SuspendAsyncFunctionProgressUntilAwaitedOutcome
    WITHOUT BlockingEntireJavaScriptRuntime;

await MAY_RESUME_WITH {
    FulfilmentValue,
    ThrownRejection
};

# ---------- EVENT LOOP ----------
EventLoop :=
    HostCoordinationMechanismForScheduledJavaScriptWork;

ExecutionModel MAY_INCLUDE {
    CallStack,
    TaskQueue,
    MicrotaskQueue
};

IF CallStackEmpty
THEN EventLoop MAY_SELECT EligibleQueuedWork;

PromiseReactions COMMONLY_USE MicrotaskProcessing;

# ---------- CALLBACK ----------
Callback :=
    FunctionPassedForLaterInvocation;

Callback MAY_BE InvokedBy {
    Event,
    Timer,
    AsyncOperation,
    HigherOrderFunction
};

# ---------- TIMER ----------
Timer :=
    HostProvidedSchedulingMechanism;

TimerCompletion DOES_NOT_GUARANTEE ExactImmediateExecutionTime;

# ---------- NETWORK REQUEST ----------
JavaScript MAY_REQUEST RemoteResource;

FetchOperation :=
    CreateRequest
    -> SendThroughHostNetworking
    -> ReceiveResponse
    -> ResolvePromise
    -> ProcessData;

NetworkFailure MAY_REJECT AsyncOperation;

# ---------- JSON ----------
JSON :=
    TextFormatForStructuredData;

JSON.parse TRANSFORMS JSONText TO JavaScriptValue;
JSON.stringify TRANSFORMS SupportedJavaScriptValue TO JSONText;

# ---------- WEB STORAGE ----------
JavaScript MAY_ACCESS HostStorageSubjectToEnvironmentAndPolicy;

Storage MAY_INCLUDE {
    LocalStorage,
    SessionStorage,
    IndexedDatabase
};

# ---------- STRICT MODE ----------
StrictMode :=
    JavaScriptExecutionModeApplyingAdditionalRestrictionsAndSemantics;

ModuleCode IS_STRICT_BY_DEFAULT;

# ---------- MEMORY ----------
JavaScriptRuntime MANAGES MemoryForReachableValues;

GarbageCollection MAY_RECLAIM UnreachableObjects;

Program SHOULD_NOT DependOn ExactGarbageCollectionTiming;

# ---------- EQUALITY ----------
EqualityOperation MAY_BE {
    StrictEquality,
    LooseEquality
};

StrictEquality AVOIDS TypeCoercionAcrossDifferentTypesInComparison;

LooseEquality MAY_APPLY CoercionRules;

# ---------- TYPE COERCION ----------
TypeCoercion :=
    ConvertValueFromOneTypeToAnotherAccordingToLanguageRules;

Coercion MAY_BE {
    Explicit,
    Implicit
};

UnexpectedImplicitCoercion MAY_CREATE LogicError;

# ---------- FUNCTIONAL PATTERNS ----------
HigherOrderFunction :=
    FunctionReceivingOrReturningFunction;

ArrayTransformation MAY_USE {
    map,
    filter,
    reduce
};

# ---------- WEB COMPONENT INTERACTION ----------
JavaScript MAY_DEFINE CustomElementBehaviour;

CustomElement MAY_PARTICIPATE_IN WebComponentArchitecture;

# ---------- SERVER-SIDE JAVASCRIPT ----------
JavaScript MAY_EXECUTE OutsideBrowserInServerRuntime;

ServerRuntime MAY_PROVIDE {
    NetworkAPIs,
    FileAPIs,
    ProcessAPIs,
    ModuleSystem
};

HostCapabilities DEPEND_ON RuntimeEnvironment;

# ---------- SECURITY ----------
JavaScriptSecurity MAY_REQUIRE {
    InputValidation,
    SafeDOMInsertion,
    OriginControls,
    ContentSecurityPolicy,
    DependencySecurity,
    LeastPrivilege
};

ExecutingUntrustedCode MAY_CREATE SecurityRisk;

UnsafeInsertionOfUntrustedHTML MAY_ENABLE ScriptInjection;

# ---------- PERFORMANCE ----------
JavaScriptPerformance MAY_BE_AFFECTED_BY {
    AlgorithmComplexity,
    DOMOperations,
    MemoryAllocation,
    NetworkRequests,
    LongRunningTasks
};

LongRunningMainThreadTask MAY_REDUCE InterfaceResponsiveness;

# ---------- ACCESSIBILITY ----------
JavaScriptDrivenInteraction SHOULD_PRESERVE {
    KeyboardAccess,
    FocusManagement,
    SemanticState,
    AccessibleNames,
    ErrorFeedback
};

DynamicDOMChange MAY_REQUIRE AccessibilityStateUpdate;

# ---------- HTML RELATIONSHIP ----------
HTML DEFINES StructureAndSemantics;
JavaScript MAY_DEFINE Behaviour;

ScriptElement MAY_LOAD JavaScript;

# ---------- CSS RELATIONSHIP ----------
JavaScript MAY_CHANGE {
    ClassAttribute,
    InlineStyle,
    StateAffectingSelectors
};

CSS THEN DeterminesPresentationFromUpdatedState;

# ---------- SEMANTIC REASONING ----------
IF SourceContainsExecutableJavaScriptSyntax
THEN JavaScriptProgramClassification := supported;

IF FunctionReferencesOuterLexicalBinding
AND FunctionOutlivesOuterExecution
THEN ClosureRelationship := supported;

IF PromiseState == Pending
THEN FulfilmentValueNotYetAvailable;

IF PromiseRejected
AND RejectionUnhandled
THEN AsyncError MAY_PROPAGATE;

IF DOMModified
THEN RenderedDocument MAY_CHANGE;

IF EventListenerRegistered
AND MatchingEventOccurs
THEN Handler MAY_BE Scheduled;

IF LongSynchronousTaskRuns
THEN UserInteractionLatency MAY_INCREASE;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "JavaScript" ~= "JS";
    "ECMAScript" ~= "JavaScript language specification basis" WHEN context == language_standard;
    "JavaScript function" ~= "JS function";
    "arrow function" ~= "arrow-function expression";
    "promise" ~= "JavaScript Promise" WHEN context == asynchronous_programming;
    "event loop" ~= "JavaScript host event loop" WHEN context == web_runtime;
    "DOM scripting" ~= "JavaScript DOM manipulation";
    "async function" ~= "asynchronous JavaScript function";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_JAVASCRIPT_ENTITIES(q) ->
    IDENTIFY_VALUES_AND_TYPES(q) ->
    IDENTIFY_SCOPE_AND_FUNCTIONS(q) ->
    IDENTIFY_OBJECT_RELATIONSHIPS(q) ->
    IDENTIFY_CONTROL_FLOW(q) ->
    IDENTIFY_ASYNCHRONOUS_BEHAVIOUR(q) ->
    IDENTIFY_WEB_INTEGRATION(q) ->
    MAP_TO_ONTOLOGY(q) ->
    APPLY_REASONING(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_RELEVANT_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        source_reliability,
        language_semantic_consistency,
        runtime_consistency,
        web_context_consistency,
        evidence_strength,
        contextual_relevance
    );

CONFIDENCE >= 0.90 => HIGH;
CONFIDENCE >= 0.70 AND < 0.90 => MODERATE;
CONFIDENCE < 0.70 => REVIEW;

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
    primary_entity: JavaScript;
    ontology: JavaScriptOntology;
    parse_entities: true;
    parse_relationships: true;
    preserve_relationship_direction: true;
    resolve_semantic_equivalence: true;
    execute_reasoning_rules: true;
    apply_confidence_weighting: true;
    preserve_provenance: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
    new_language_entity:
        validate
        -> classify
        -> identify_scope_or_type
        -> relate
        -> integrate;

    new_function:
        identify_parameters
        -> identify_lexical_environment
        -> identify_calls
        -> identify_return_behaviour
        -> integrate;

    new_async_relationship:
        identify_operation
        -> identify_promise_or_callback
        -> identify_scheduling_context
        -> update_event_loop_model
        -> integrate;

    program_revision:
        reparse_program
        -> update_bindings
        -> update_call_relationships
        -> recompute_async_dependencies
        -> recompute_confidence
        -> regenerate_flow_hash;

    conflict:
        preserve_provenance
        -> compare_language_semantics
        -> adjust_confidence
        -> flag_review;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + JavaScriptEntity
    + ValueType
    + ExecutionEntity
    + WebIntegrationEntity
    + PromiseState
    + EventLoop
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
JavaScriptOntology
    -> ParseProgram
    -> EstablishBindingsAndScopes
    -> EvaluateStatementsAndExpressions
    -> CreateAndInvokeFunctions
    -> ManipulateObjectsAndData
    -> RespondToEvents
    -> ScheduleAsynchronousOperations
    -> ResolvePromisesAndCallbacks
    -> InteractWithDOMAndWebAPIs
    -> UpdateApplicationState
    -> PreserveSecurityAndAccessibility
    -> MaintainExecutableWebBehaviour;

END FLOW